Todo el mundo sabe pi la constante matemática, la razón de la circunferencia de un círculo a su diámetro.

3.14159265358979323846264338327950288419716939937510...

Es probable que también sabe ae la constante matemática, la base de un logaritmo natural.

2.71828182845904523536028747135266249775724709369996...

Pero ... ¿sabes pastel ? Es una de las constantes más importantes (para mí). Son los dígitos de pi y e intercalados.

32.1741185298216852385485997094352233854366206248373...

Como una expansión decimal:

3, 2, 1, 7, 4, 1, 1, 8, 5, 2, 9, 8, 2, 1, 6, 8, 5, 2...

Esta es la secuencia OEIS A001355 .

PALABRA CLAVE: nonn, base, tonto , fácil

Es una secuencia muy tonta.

Reto

Escriba un programa / función que tome un número entero no negativo n y genere el enésimo dígito del pastel .

Presupuesto

• Normas estándar de E / S se aplican .
• Las lagunas estándar están prohibidas .
• Su solución debe funcionar con al menos 50 dígitos de cada constante, lo que significa que debe funcionar con al menos 100 términos de la secuencia (por favor, intente no codificar: P).
• La salida para 2 o 3 no es un punto decimal .
• Su solución puede estar indexada a 0 o indexada a 1, pero especifique cuál.
• Este desafío no se trata de encontrar el enfoque más corto en todos los idiomas, sino de encontrar el enfoque más corto en cada idioma .
• Su código se puntuará en bytes , generalmente en la codificación UTF-8, a menos que se especifique lo contrario.
• Las funciones integradas que calculan esta secuencia están permitidas, pero se recomienda incluir una solución que no se base en una función integrada.
• Se alientan las explicaciones, incluso para los idiomas "prácticos" .

Casos de prueba

Estos están indexados a 0.

Input   Output

1       2
2       1
11      8
14      6
21      4
24      9
31      5

En algunos formatos mejores:

1 2 11 14 21 24 31
1, 2, 11, 14, 21, 24, 31

2 3 12 15 22 25 32
2, 3, 12, 15, 22, 25, 32

Mathematica, 50 bytes

1 indexado

(Riffle@@(#&@@RealDigits[#,10,5!]&/@{Pi,E}))[[#]]& 

Haskell, 154 147 146 bytes, SIN CODIFICACIÓN O USO DE CONSTANTES CONSTRUIDOS

Esta solución calcula e y pi utilizando series infinitas y las almacena en enteros de punto fijo de precisión arbitraria (el tipo incorporado de Haskell Integery su Rationalextensión).

import Data.Ratio
s n=product[n,n-2..1]
r=[0..164]
f n=(show$round$(*10^50)$sum[[2*s(2*k)%(2^k*s(2*k+1)),1%product[1..k]]!!mod n 2|k<-r])!!div n 2

Sin golf:

import Data.Ratio

semifact :: Integer -> Integer
semifact n = product [n, n-2..1]

pi_term :: Integer -> Rational
pi_term i = semifact (2*i) % (2^i * semifact (2*i+1))

--requires 164 terms to achieve desired precision
pi_sum :: Rational
pi_sum = 2 * (sum $ map (pi_term) [0..164])

--requires 40 terms to achieve desired precision
e_sum :: Rational
e_sum = sum [1 % product [1..k] | k<-[0..40]]

-- 51 digits are required because the last one suffers from rounding errors 
fifty1Digits :: Rational -> String
fifty1Digits x = show $ round $ x * 10^50

pi51 = fifty1Digits pi_sum
e51  = fifty1Digits e_sum

-- select a string to draw from, and select a character from it
pie_digit n = ([pi51, e51] !! (n `mod` 2)) !! (n `div` 2)

0 indexado. Preciso para la entrada 0-99, impreciso para la entrada 100-101, fuera de los límites de lo contrario.

Explicación:

Calcula pi usando esta serie infinita . Calcula e utilizando la serie factorial inversa clásica . Teóricamente, estas no son las fórmulas ideales para usar, ya que no son muy concisas en términos de bytecount, pero fueron las únicas que pude encontrar que convergieron lo suficientemente rápido como para hacer posible la verificación de la precisión (otras sumas requieren cientos de miles si no millones de términos). En la versión de golf, e se calcula con una precisión mucho mayor que la necesaria para minimizar el bytecount. Ambas constantes se calculan con un poco más de dígitos de lo necesario para evitar errores de redondeo (que son responsables de la incómoda cola de valores incorrectos).

Las constantes se calculan como relaciones enteras de precisión arbitraria ( Rational), luego se multiplican por 10 ^ 50 para que todos los dígitos necesarios permanezcan intactos cuando la relación se convierte en un entero (precisión arbitraria) ( Integer). Esto también evita el problema de evitar el punto decimal en las representaciones de cadena de los números, de la que la función extrae caracteres alternativamente.

Taxi , 749 bytes.

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919' is waiting at Writer's Depot.Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to The Underground.Go to Writer's Depot:n 1 l 1 l 2 l.Pickup a passenger going to Chop Suey.Go to Chop Suey:n 3 r 3 r.[a]Pickup a passenger going to Narrow Path Park.Go to The Underground:s 1 r 1 l.Switch to plan "b" if no one is waiting.Pickup a passenger going to The Underground.Go to Narrow Path Park:n 4 l.Go to Chop Suey:e 1 r 1 l 1 r.Switch to plan "a".[b]Go to Narrow Path Park:n 4 l.Pickup a passenger going to Post Office.Go to Post Office:e 1 r 4 r 1 l.

Pruébalo en línea!

Intentar calcular pi o e programáticamente en Taxi sería una pesadilla, aunque estoy seguro de que se puede hacer. Por lo tanto, es mucho más corto codificar los primeros 100 dígitos de la secuencia. Se siente bastante barato, pero definitivamente es el código de Taxi más corto que cumple con el desafío.

Codifica la secuencia como cadenas, toma n, luego itera nhacia abajo y elimina el primer carácter de la cadena cada vez. Cuando n=0, muestra el primer caracter. Esto es un índice.

Sin golf / formateado:

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919' is waiting at Writer's Depot.
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to The Underground.
Go to Writer's Depot: north 1st left 1st left 2nd left.
Pickup a passenger going to Chop Suey.
Go to Chop Suey: north 3rd right 3rd right.
[a]
Pickup a passenger going to Narrow Path Park.
Go to The Underground: south 1st right 1st left.
Switch to plan "b" if no one is waiting.
Pickup a passenger going to The Underground.
Go to Fueler Up: south.
Go to Narrow Path Park: north 4th left.
Go to Chop Suey: east 1st right 1st left 1st right.
Switch to plan "a".
[b]
Go to Narrow Path Park: north 4th left.
Pickup a passenger going to Post Office.
Go to Post Office: east 1st right 4th right 1st left.

Python 2 , 88 bytes

-4 bytes gracias a la idea de conversión base de @EriktheOutgolfer .

lambda n:`int("SVBPXJDZK00YCG3W7CZRA378H4AM5553D52T52ZKAFJ17F4V1Q7PU7O4WV9ZXEKV",36)`[n]

Pruébalo en línea!

Python 2 + sympy , 92 bytes

0 indexado. Gracias a Rod por recordarme que me cambiara from sympy import*, lo que anteriormente olvidé.

lambda n:sum([('3','2')]+zip(`N(pi,50)`,`N(E,50)`[:47]+'6996')[2:],())[n]
from sympy import*

Pruébalo en línea!

Python 2 , 114 bytes

Sinceramente, creo que la solución más corta es la codificación, ya que Python no tiene incorporados útiles.

lambda n:"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Pruébalo en línea!

Python 2 , 114 bytes

Solución equivalente por @totallyhuman .

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919'.__getitem__

Pruébalo en línea!

05AB1E , 10 bytes

žsтžtøJþsè

Explicación:

žs          Get the first input digits of pi
  тžt       Get 100 digits of e
     ø      Zip them together
      J     Join into a string
       þ    Remove non-digits
        sè  0-indexed index of input in the resulting list

0 indexado.

Pruébalo en línea!

Python 3 , 83 80 bytes

0 indexado.

lambda n:('%d'*51%(*b' )4bD4&6UcF^#!U+B>0%"WK\<>0^GO9~1c]$O;',))[n]

Pruébalo en línea!

Hay algunos caracteres no imprimibles allí que no se pueden ver correctamente en un navegador.

Esto funciona construyendo la tupla a (32, 17, 41, 18, 52, ...)partir de los códigos ASCII de los caracteres en la cadena de bytes codificada. La tupla se convierte en la cadena '3217411852...', de la cual seleccionamos el dígito correcto.

Políglota, 108 bytes

n=>"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Trabaja en:

• DO#
• JavaScript

Creo que esto es lo más corto que puedes hacer en C # ya que son 252 bytes para encontrar el enésimo decimal de pi .

Java 8, 420 417 413 404 380 358 (calculado) y 115 110 (hardcoded) bytes

Calculado ( 420 417 413 404 380 358 ):

import java.math.*;n->{int i=1,x=99;BigDecimal e,f=e=BigDecimal.ONE;BigInteger p,a=BigInteger.TEN.pow(x);for(p=a=a.add(a);i<x;)e=e.add(e.ONE.divide(f=f.multiply(f.valueOf(i++)),new MathContext(x,RoundingMode.HALF_UP)));for(i=1;a.compareTo(a.ZERO)>0;)p=p.add(a=a.multiply(a.valueOf(i)).divide(a.valueOf(i+++i)));return n==1?50:((n%2<1?p:e)+"").charAt(-~n/2);}

Pruébalo aquí
Demuestre que genera el resultado correcto para los 100 elementos necesarios.

Codificado: ( 115 110 bytes ):

"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"::charAt

Pruébalo en línea.

0 indexado

-9 y -5 bytes gracias a @Nevay .
-24 bytes gracias a @ceilingcat .

• Su solución debe funcionar durante al menos 50 dígitos de cada constante, lo que significa que debería funcionar durante al menos 100 términos de la secuencia (por favor, intente no codificar: P)
• Las funciones integradas que calculan esta secuencia están permitidas, pero se recomienda incluir una solución que no se base en una función integrada.

Lo has pedido ...;)

Java está integrado Math.PIy Math.Eson dobles, que tienen una precisión máxima de solo 16. Por lo tanto, tendremos que calcular ambos valores nosotros mismos usando java.math.BigIntegery / o java.math.BigDecimal.
Como ya he calculado PI antes en otro desafío , he usado el mismo código usando BigInteger. BigDecimalSin embargo, el algoritmo para el número de Euler se usa .
El resultado py eson por lo tanto: 31415...y2.718... .

Probablemente podría jugar golf solo usando BigDecimal, pero estaba dando algunas respuestas incorrectas para PI, así que ahora uso ambos BigDecimaly BigInteger.

Explicación:

import java.math.*;           // Required import for BigDecimal and BigInteger
n->{                          // Method with integer as parameter and char as return-type
  int i=1,                    //  Start index-integer at 1
      x=99;                   //  Large integer we use three times
  BigDecimal e,               //  Euler's number
             f=e=BigDecimal.ONE;
                              //  Temp BigDecimal (both `e` and `f` start at 1)
  BigInteger p,               //  PI
             a=BigInteger.TEN.pow(x);for(p=a=a.add(a);
                              //  Temp BigInteger (where both `p` and `a` starts at 10^99*2)

       i<x;)                  //  Loop (1) 99 times (the higher the better precision)
    e=e.add(                  //   Add the following to `e`:
       e.ONE.divide(f=f.multiply(f.valueOf(i++)),
                              //    First change `f` by multiplying it with `i`
        new MathContext(x,RoundingMode.HALF_UP))))
                              //    And then add 1/`f` to `e`
                              //    (RoundingMode is mandatory for BigDecimal divide)
  for(i=1;                    //  Reset `i` back to 1
      a.compareTo(a.ZERO)>0;) //  Loop (2) as long as `a` is not 0
    p=p.add(                  //   Add the following to `p`:
       a=a.multiply(a.valueOf(i))
                              //    First change `a` by multiplying it with `i`,
          .divide(a.valueOf(i+++i)));
                              //    and dividing it by `2*i+1`
                              //    And then add this new `a` to `p`
  // We now have `p`=31415... and `e`=2.718...
  return n==1?                // If the input (`n`) is 1:
          50                  //  Return 2
         :                    // Else:
          ((n%2<1?            //  If `n` is divisible by 2:
             p                //   Use `p`
            :                 //  Else:
             e)               //   Use `e` instead
    +"")                      //  Convert BigDecimal/BigInteger to String:
        .charAt(-~n/2);}      //  And return the `(n+1)//2`'th character in this string

Semilla , 6015 bytes

105 41100973201674650461227976639700390615120600528953176107701316721890649738810349651490948904154731057172335535600875054878204557287393379815378680878571406244365932330202793040308312687924242319799562985464135998860369933720376853281630432469462831217924775601393232895404104191613314969008627719099002734936685651970933027922574843126481552407811220371545812798263882325951724505132794956253992779856191832909434513683936955184871247159313261417328850445886987045814618325821125417040265540589403338721758954467831926977078444612065747526326682314711350486782090838673475876960125016098416460032667015813053483457246043486676622061645094043655351781242050448580132075920324099742699960838361839038297355120817832056960516761862493176616153258281345538652844974811030063414112136642097000574165433957710342430709643110444042577685157477268110199017600011209827070311299268347100419887111107237908884608557593677163764286026624394674781868689858494991328505977301270068505397030743037416430245399054325956185200430657008806539374392625804513081295070438243600044274289109395357299275275193717501822777898664715885427884193864182834402097958423697356485767670945673525604620701482288023981110598866625872386643941558021439168402392304238271452444124214301243311025121833097491087918320170873313832323794851508364788578530614246140801266858481189449278157296335592848066512127882306035576754122325822200069362884409931190620435627809384380203617488253034370361172908245852012086081807945576657014184275798330804532115103840313004678040210379846666674881048346897213048386522262581473085489039138251061251160730845385869281787222083186331344552658814775998639661361866503862291670619153718574270905089351133527806484519543645501497150560454761284099358123613642350160410944676702481576280832672884549762767667090615809061739499629798396737503512011645776394176807352443544839957773371384141101627375926404212619777658374366513665083032140398814384622434755543347503025479743718569310129255927244046638238401670388409731849963600790867434678993019370132638962549859363736476668247251402420832876258626149639101811361047924632565285870213656416957893835899254928237592711662454838295046528789720146967061486405916116778722736283489123195985053535189375957277052428901645131462087039117212488839670735246752589931585405440449333046667938628384693216121067951290025349082277568986632815062532963505690244579740140120806885104683071514922412748240497612209609661707922754236180441892543545377867355182682381812487973645406703590150722720330526173957597156314579144484166520730013480681064941752984345205140917291104888971742824066713606933406657345121342075268990055328274845008936364502884461548416337689565392911129757761902576946104722487260155373897552821908338346641549478063474748830482136404008215583192489320750526753663943267086203954602839906762640389978523894333743126288529975769945319614142422443068420170103245659109689433597701350198280212250954698442638475209618790055335813263132865176791663235801963797561493995544185124734214257034901773781134331460320221759556924556747571745834582344275416625351302153332814233497096345055392255809024712740720006219615340819493781244665414077298346378966540544979367367978334759985048507214749726072645238624803791884339024844989975370042133733339339038567691571361407296615851372112592532463329778465699812822089846474961581380707849259093905314170108054540333209088059730272087864344697983074458088984533095183089310714804468718319244214535941276969904638763288063417624586766891798378622613765728303031397998644194508610598078718347204813844240434145846888722334194516524032354042557957058092854659539699310565707914118281251563405735083553254856313838760124953245573676126601070861004186509621892263623745673900572829301771299438501543213489182375655869072568437776298051260531944785904157204006430131566234389896821642210616326951771496269255716808352415001187083781128619236455170025989777631182990311607133740812107138446626302353752098982590371714623080450836912706275397973009559314275978915463843159370230629290376520494894845680706499809017211545204670148071902560908658269183779180493590025891585269507219866461550160579656755846447951259951641828495549544791046179035585611272240116822105364823082512055639047431280117805724371019657801828634946412396263504315569042536942671358095826696817513115447079645898107923447321583282886740680340887700198072304400536529418546232473450984945589794448490331085275232352881571706521961358975744067916422124670374397682877259664913100427726059898474024964867713698696116581478101206003313106174761699804016604950094008714907179862448792216891309734208815522069346791369498202430302292199779590583788518283934542807403049256936179914953814019565550264909025345322516061595136601312434888871667940394250767164496543418483237896796108764367721411969986710930448108645039275082356457263454340220118278471652962484104099512207532103709146426640958406853240342441810465024550617909657901698718289260589269758398513490424434162831332785821428006396653475356712733072469052427934231406388810607688824035522285626563562286337967271308076321307276537761026788485320280603487776428017017298356181654076403306265118978333909378403193559129146468182910851996415072056976175613473847242292911071040966109905552914332596680497156169349277079292398091020434667210493868422848588893205157133171899819212153010393580099455957808703428739456223073813663954919146593698106305501988107196273527346690785289909397140611634970017071011599022429384594426022933102487171920965595473754661194965266230932928905708783854897164127767575976566931916632077914904360565095752466049885656187054491320449776951484812738806536727562344348761718424255018794271994537719709226236497935053971406685810778014002594041715040546776952342303797267458880802314841325359844565479173256964507237937290466116935912176054052746039378370966040054779443633371806403649852746347690237831260027483859907620684197542069045517397230169577918374265220969534695931904

La semilla equivalente a mi respuesta Befunge. Como mencioné allí, el programa Befunge que esto genera no funciona en TIO porque TIO parece tener un ajuste de línea interno de 80 caracteres.

Excel, 113 bytes

1 indexado

=MID("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1)

PI()solo tiene una precisión de hasta 15 dígitos. Similar para EXP(1).

60 Solución de 42 bytes que funciona para Input <=30 (-18 bytes gracias a @Adam)

=MID(IF(ISODD(A1),PI(),EXP(1)/10)/10,A1/2+3,1)

05AB1E , 13 bytes

Éi<;žtë;žs}þθ

Pruébalo en línea!

Similar a la respuesta de Magic, pero un poco diferente.

Explicación:

Éi<;žtë;žs}þθ Supports 9842 digits of e and 98411 digits of π
É             a % 2
 i    ë   }   if a==1
  <            a - 1
   ;           a / 2
    žt         e to a digits
              else
       ;       a / 2
        žs     π to a digits
           þ  keep chars in [0-9] in a
            θ a[-1]

Python 2 + SymPy , 70 63 bytes

lambda n:int(N([pi,E][n%2],50)*10**(n/2)%10)
from sympy import*

Pruébalo en línea!

Japt , 55 bytes

" ®v4bØUî6UcF^#ß&6$Îø%\"Wí;<>0^GO9G1c]$O;"cs gU

¡Pruébelo en línea!Contiene algunos no imprimibles.

Funciona reemplazando cada carácter en la cadena con su código de caracteres, luego devuelve el dígito en el índice correcto. La cadena fue generada por este programa:

r"..(?=[^0]0)|25[0-5]|2[0-4].|1..|.(?=[^0]0)|..|."_n d

¡Pruébelo en línea!

Julia, 63 bytes

1 indexado

a(n)=replace(string(BigFloat(n%2>0?π:e)),'.',"")[ceil(Int,n/2)]

Convierte pi o e en una cadena, elimina el lugar decimal y luego llama al dígito apropiado. Devuelve una representación de caracteres del dígito.

Semilla, 5852 5794

Basado en la respuesta de TehPers Befunge.

1051130021648715907393149878290493079600376561988348664272369051219541158034251323778110172612675089859184605166991106040693833909592598132115295033728752738087105881243462563076466678196376225832661747114302365429787133716511111381612588140144307910362782924144996564529411691568302571546828919454271683233497896594149189544327214969302848984257909609092418942847813158570493297692245428646803536815345759334224247677074872671057296478697076157019699466324478990259351466108726578472175001474585821629778406880297836753303012207209976229264609834293181367664486642493394085473509253813676093779567738697465957519812706192139261472118908699638816640825554051850436762061721281771892466822470585742923158999350909054375916612667405594051622229969696110285582900916410099224974902720736021096981441362371398922887585642863359978062601767338412679956208026294953110185271056006145171920926497396179933553547647876354874445336583594285656870801545177578902705927733720249211636847884869491097054175976937629709200212494761217184873108852140655722895359613462156833646123152648220793295854627649452190956799160703532861477096009725706141202331131287901266622861560576869037209421378739125115765163010112273561384890274706972479335859548424507413589440122160717697618157336618754196528390529316634155057447126317467878320143220148685911507025731721669456692292309133633447284353130542004299981319048073637696567634889623949341630372505055435189663767044165063763216111834588696399179737702861529836947970901482712510136315042152110633215913241916694919566433112405210063414042670097562256073600916103886503591248191758835092924394147776204171675226850914902590401360360345796925181247981647089261884952039081268986586818659090505317955579671089885915745568661758883469031230794272571159213300281445730703294269295310767401339422952480777920786878410780792687195268799097885426801795242758273587841272731685278721369746727313447085996142152811199340656395207452343492937579702451111716453371016654791322834865918860033642314402995240481293652425792697358895577606699947511030416728684352022506710677976841690749387202992493347056114389784733211172448656007595582911222364847293116425714996343958156522448560363063094260073906846664112391722958505451464414025605603413323283807093107521955579711235903403153357003170132938512689946882757999117710160645821945148763813674548797981224375547254576063310479473749044201972863935442758458424285806147218666471747061869918574545072745631758049982372007444866300485095061433951914878373501952670216546435388818497342311417254246013304856715094953051481317438104933875171470343900106719705171102058673610594748846178562080370992488881764909402902065625464750558527389775735939044400858705229893243673486621988009838791971714603625037310885148140796813757120291067372196872928228321095156712054303101901959874384063672886495472796070113365603843687513322867176197917489855537726934095360491472497352567147140246395682503059404971449739625647398820598964158265302668783916501984956044969021302601920487717382879106303683795359905325347814473318519391344565458920270463279174784746656360314070464241666622240210385245184959282222666398870656274940629675453574246097799383361429014800618720780346294542185892116417842240524776835458087900018007896901140383243611793705883547791450682392261960643824271328189332116466519255567441515615925840284456154022304291978218634565379575148642711337622789721842048696443945213454162713556316912301346193615227854869318871089808249776555077834342492281888561676171087168150941237306007109521081900169693331625918138699682645157924632842546989812618292449480799580909720292280095095845962850721356554807680991288722147671740885576811339492549454926901594927338274410385863276725958781460924134466358260089533908525106740467122470973368676988277207568882122479840074670300214980511007665457235218290742394089204192282508491125777180151491866961638111244962953268398339686189772372983926068579350047402754803068232034594024872791141428095120311259087973136353149728638143035136784730999270266072749004567217555438270988124997549762230020689881669285499865374963053282530118570884108038975805335341098720577305266629567047445192403700472887794782423940658412176424370062158626834653405675401415679083822191617061925174149189203359499283160374801737260780407460559147326758994495549579747033361234471750470244513311080274649191860724511086222353696966556035904101416366866518427071604705222938635947781869520181137451408849640159586041113639598272540062185768190959707775362176381804238896341317485410279831458927597060094913931822437950489034755418876566165098609145551163170170060968550804192429683076682433548504113044161906874992120619724109268394986529182050977866104283639955069424323124118234270471868688405770066267298550544345355480568344482162465184049105391961294335245926910436280167548428908725073049063187423431751542064521517069452498182346407984197390998799924644160478679731476796691938148057603728267749331459031937823996495889234787060791079241854542581243078812931046333013380737766914161425371301455762684652883345176576166320850926855173197613536554369628772428747263956045786416295429184651985570482338242016559363725421100270243627030197439290918962948652873397874243832067459791837014394278403085907234616003231621600132126403225123227458214686006897240158060744989458215243787817148717936756981074208678765977744940577875579654698779849605118845010395906232293740180888137656291524050590071724242335942378834532707622396324405477279768052696927856056064019532570357101573277570040254706775462396160275876038886428146097798897998315086627358220951838049046100218938610753230860169099104474379950181692561834872540511195903774693113510283120187768500261160296892119883913289017641545057765550924909632887927659777449405778755796546987798496051188450103959062322937401808881376562915240505900717242423359423788345327076223963244054772797680526969278560560640195325703571015732775700402547067754623961602758760388864281460977988979983150866273582209518380490461002189386107532308601690991044743799501816925618348725405111959037746931135102831201877685002611602968921198839132890176415450577655509249096328879276597774494057787557965469877984960511884501039590623229374018088813765629152405059007172424233594237883453270762239632440547727976805269692785605606401953257035710157327757004025470677546239616027587603888642814609779889799831508662735822095183804904610021893861075323086016909910447437995018169256183487254051119590377469311351028312018776850026116029689211988391328901764154505776555092490963288792

Malbolge Unshackled (variante de rotación de 20 trits), 3,64E6 bytes

El tamaño de esta respuesta excede el tamaño máximo de programa postable (eh), por lo que el código es encuentra en mi repositorio de GitHub (nota: no copie el código usando CTRL + A y CTRL + C, simplemente haga clic derecho y haga clic en "Guardar elemento de destino como. .. ").

¿Cómo ejecutar esto?

Esto podría ser una parte difícil, porque el ingenuo intérprete de Haskell tardará siglos en ejecutarlo. TIO tiene un intérprete decente Malbogle Unshackled, pero lamentablemente no podré usarlo (limitaciones).

La mejor que pude encontrar es la variante de ancho de rotación fija de 20 trits, que funciona muy bien, calculando (más o menos) al instante .

Para hacer que el intérprete sea un poco más rápido, eliminé todas las comprobaciones del intérprete Malbolge Unshackled de Matthias Lutter.

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const char* translation = "5z]&gqtyfr$(we4{WP)H-Zn,[%\\3dL+Q;>U!pJS72Fh"
        "OA1CB6v^=I_0/8|jsb9m<.TVac`uY*MK'X~xDl}REokN:#?G\"i@";

typedef struct Word {
    unsigned int area;
    unsigned int high;
    unsigned int low;
} Word;

void word2string(Word w, char* s, int min_length) {
    if (!s) return;
    if (min_length < 1) min_length = 1;
    if (min_length > 20) min_length = 20;
    s[0] = (w.area%3) + '0';
    s[1] = 't';
    char tmp[20];
    int i;
    for (i=0;i<10;i++) {
        tmp[19-i] = (w.low % 3) + '0';
        w.low /= 3;
    }
    for (i=0;i<10;i++) {
        tmp[9-i] = (w.high % 3) + '0';
        w.high /= 3;
    }
    i = 0;
    while (tmp[i] == s[0] && i < 20 - min_length) i++;
    int j = 2;
    while (i < 20) {
        s[j] = tmp[i];
        i++;
        j++;
    }
    s[j] = 0;
}

unsigned int crazy_low(unsigned int a, unsigned int d){
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    int position = 0;
    unsigned int output = 0;
    while (position < 10){
        unsigned int i = a%3;
        unsigned int j = d%3;
        unsigned int out = crz[i+3*j];
        unsigned int multiple = 1;
        int k;
        for (k=0;k<position;k++)
            multiple *= 3;
        output += multiple*out;
        a /= 3;
        d /= 3;
        position++;
    }
    return output;
}

Word zero() {
    Word result = {0, 0, 0};
    return result;
}

Word increment(Word d) {
    d.low++;
    if (d.low >= 59049) {
        d.low = 0;
        d.high++;
        if (d.high >= 59049) {
            fprintf(stderr,"error: overflow\n");
            exit(1);
        }
    }
    return d;
}

Word decrement(Word d) {
    if (d.low == 0) {
        d.low = 59048;
        d.high--;
    }else{
        d.low--;
    }
    return d;
}

Word crazy(Word a, Word d){
    Word output;
    unsigned int crz[] = {1,0,0,1,0,2,2,2,1};
    output.area = crz[a.area+3*d.area];
    output.high = crazy_low(a.high, d.high);
    output.low = crazy_low(a.low, d.low);
    return output;
}

Word rotate_r(Word d){
    unsigned int carry_h = d.high%3;
    unsigned int carry_l = d.low%3;
    d.high = 19683 * carry_l + d.high / 3;
    d.low = 19683 * carry_h + d.low / 3;
    return d;
}

// last_initialized: if set, use to fill newly generated memory with preinitial values...
Word* ptr_to(Word** mem[], Word d, unsigned int last_initialized) {
    if ((mem[d.area])[d.high]) {
        return &(((mem[d.area])[d.high])[d.low]);
    }
    (mem[d.area])[d.high] = (Word*)malloc(59049 * sizeof(Word));
    if (!(mem[d.area])[d.high]) {
        fprintf(stderr,"error: out of memory.\n");
        exit(1);
    }
    if (last_initialized) {
        Word repitition[6];
        repitition[(last_initialized-1) % 6] =
                ((mem[0])[(last_initialized-1) / 59049])
                    [(last_initialized-1) % 59049];
        repitition[(last_initialized) % 6] =
                ((mem[0])[last_initialized / 59049])
                    [last_initialized % 59049];
        unsigned int i;
        for (i=0;i<6;i++) {
            repitition[(last_initialized+1+i) % 6] =
                    crazy(repitition[(last_initialized+i) % 6],
                        repitition[(last_initialized-1+i) % 6]);
        }
        unsigned int offset = (59049*d.high) % 6;
        i = 0;
        while (1){
            ((mem[d.area])[d.high])[i] = repitition[(i+offset)%6];
            if (i == 59048) {
                break;
            }
            i++;
        }
    }
    return &(((mem[d.area])[d.high])[d.low]);
}

unsigned int get_instruction(Word** mem[], Word c,
        unsigned int last_initialized,
        int ignore_invalid) {
    Word* instr = ptr_to(mem, c, last_initialized);
    unsigned int instruction = instr->low;
    instruction = (instruction+c.low + 59049 * c.high
            + (c.area==1?52:(c.area==2?10:0)))%94;
    return instruction;
}

int main(int argc, char* argv[]) {
    Word** memory[3];
    int i,j;
    for (i=0; i<3; i++) {
        memory[i] = (Word**)malloc(59049 * sizeof(Word*));
        if (!memory) {
            fprintf(stderr,"not enough memory.\n");
            return 1;
        }
        for (j=0; j<59049; j++) {
            (memory[i])[j] = 0;
        }
    }
    Word a, c, d;
    unsigned int result;
    FILE* file;
    if (argc < 2) {
        // read program code from STDIN
        file = stdin;
    }else{
        file = fopen(argv[1],"rb");
    }
    if (file == NULL) {
        fprintf(stderr, "File not found: %s\n",argv[1]);
        return 1;
    }
    a = zero();
    c = zero();
    d = zero();
    result = 0;
    while (!feof(file)){
        unsigned int instr;
        Word* cell = ptr_to(memory, d, 0);
        (*cell) = zero();
        result = fread(&cell->low,1,1,file);
        if (result > 1)
            return 1;
        if (result == 0 || cell->low == 0x1a || cell->low == 0x04)
            break;
        instr = (cell->low + d.low + 59049*d.high)%94;
        if (cell->low == ' ' || cell->low == '\t' || cell->low == '\r'
                || cell->low == '\n');
        else if (cell->low >= 33 && cell->low < 127 &&
                (instr == 4 || instr == 5 || instr == 23 || instr == 39
                    || instr == 40 || instr == 62 || instr == 68
                    || instr == 81)) {
            d = increment(d);
        }
    }
    if (file != stdin) {
        fclose(file);
    }
    unsigned int last_initialized = 0;
    while (1){
        *ptr_to(memory, d, 0) = crazy(*ptr_to(memory, decrement(d), 0),
                *ptr_to(memory, decrement(decrement(d)), 0));
        last_initialized = d.low + 59049*d.high;
        if (d.low == 59048) {
            break;
        }
        d = increment(d);
    }
    d = zero();

    unsigned int step = 0;
    while (1) {
        unsigned int instruction = get_instruction(memory, c,
                last_initialized, 0);
        step++;
        switch (instruction){
            case 4:
                c = *ptr_to(memory,d,last_initialized);
                break;
            case 5:
                if (!a.area) {
                    printf("%c",(char)(a.low + 59049*a.high));
                }else if (a.area == 2 && a.low == 59047
                        && a.high == 59048) {
                    printf("\n");
                }
                break;
            case 23:
                a = zero();
                a.low = getchar();
                if (a.low == EOF) {
                    a.low = 59048;
                    a.high = 59048;
                    a.area = 2;
                }else if (a.low == '\n'){
                    a.low = 59047;
                    a.high = 59048;
                    a.area = 2;
                }
                break;
            case 39:
                a = (*ptr_to(memory,d,last_initialized)
                        = rotate_r(*ptr_to(memory,d,last_initialized)));
                break;
            case 40:
                d = *ptr_to(memory,d,last_initialized);
                break;
            case 62:
                a = (*ptr_to(memory,d,last_initialized)
                        = crazy(a, *ptr_to(memory,d,last_initialized)));
                break;
            case 81:
                return 0;
            case 68:
            default:
                break;
        }

        Word* mem_c = ptr_to(memory, c, last_initialized);
        mem_c->low = translation[mem_c->low - 33];

        c = increment(c);
        d = increment(d);
    }
    return 0;
}

05AB1E , 14 bytes

žssžt‚øJ'.Ks<è

Pruébalo en línea!

Esta respuesta está indexada a 0.

žs              # pi to N digits.
  sžt           # e to N digits.
     ‚øJ        # Interleave.
        '.K     # No decimal points.
           s<è  # 0-indexed digit from string.

Python 3 + SymPy , 109 bytes

0 indexado Pruébelo en línea!

from mpmath import*
mp.dps=51
print(''.join(['32']+[str(pi)[i]+str(e)[i]for i in range(2,51)])[int(input())])

Batir la codificación por 5 bytes !! Pero probablemente podría ser mejor. Pero superar el hardcoding me hace sentir bien :)

Pyth, 35 bytes

@.i`u+/*GHhyHyK^T99rJ^2T0Z`sm/K.!dJ

Banco de pruebas

Como Pyth no tiene constantes de precisión arbitraria pi y e incorporadas, las calculo directamente.

Calculando pi:

u+/*GHhyHyK^T99rJ^2T0

Este sistema utiliza la siguiente recurrencia continuaron fracción de pi cálculo: 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + ...)))). Lo obtuve de otra respuesta PPCG . Se deriva en las ecuaciones 23-25 aquí .

Lo calculo de adentro hacia afuera, omitiendo todos los términos más allá del 1024, ya que los términos posteriores tienen poco efecto en el número, y mantengo 99 dígitos de precisión para asegurarme de que los primeros 50 sean correctos.

Calculando e:

sm/K.!dJ

Sumo los recíprocos de los primeros 1024 números, a 99 dígitos de precisión.

Luego, convierto ambos números en cadenas, los entrelazo y los indexo.

MATLAB, 93 Bytes

n=input('');
e=num2str(exp(1));
p=num2str(pi);
c=[];
for i=1:length(p)
 c=[c p(i) e(i)];
end;
c(n)

Una explicación simple es que esto primero convierte e y pi en cadenas, luego pasa por un bucle for que concatena los dígitos. Aquí, c es pastel, p es pi y e es e.

También he dividido esto en varias líneas para facilitar la lectura, pero el código real está en una sola línea con un espaciado mínimo.

C # + BigDecimal , 377 372 bytes

d=>{if(d%2<1){d/=2;int l=++d*10/3+2,j=0,i=0;long[]x=new long[l],r=new long[l];for(;j<l;)x[j++]=20;long c,n,e,p=0;for(;i<d;++i){for(j=0,c=0;j<l;c=x[j++]/e*n){n=l-j-1;e=n*2+1;r[j]=(x[j]+=c)%e;}p=x[--l]/10;r[l]=x[l++]%10;for(j=0;j<l;)x[j]=r[j++]*10;}return p%10;}else{CognitioConsulting.Numerics.BigDecimal r=1,n=1,i=1;for(;i<99;)r+=n/=i++;return(r+"").Remove(1,1)[d/2]-48;}}

Guardado 5 bytes gracias a @Kevin Cruijssen.

No hay un enlace TIO debido a la biblioteca externa, desafortunadamente C # no tiene una BigDecimalclase integrada, por lo que esta externa tendrá que funcionar. Probablemente todavía sea posible jugar al golf, pero no hay tiempo en este momento.

Versión completa / formateada:

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<int, long> f = d =>
            {
                if (d % 2 < 1)
                {
                    d /= 2;

                    int l = ++d * 10 / 3 + 2, j = 0, i = 0;
                    long[] x = new long[l], r = new long[l];

                    for (; j < l;)
                        x[j++] = 20;

                    long c, n, e, p = 0;

                    for (; i < d; ++i)
                    {
                        for (j = 0, c = 0; j < l; c = x[j++] / e * n)
                        {
                            n = l - j - 1;
                            e = n * 2 + 1;
                            r[j] = (x[j] += c) % e;
                        }

                        p = x[--l] / 10;
                        r[l] = x[l++] % 10;

                        for (j = 0; j < l;)
                            x[j] = r[j++] * 10;
                    }

                    return p % 10;
                }
                else
                {
                    CognitioConsulting.Numerics.BigDecimal r = 1, n = 1, i = 1;

                    for (; i < 99;)
                        r += n /= i++;

                    return (r + "").Remove(1,1)[d/2] - 48;
                }
            };

            for (int i = 0; i < 100; ++i)
            {
                Console.Write(f(i));
            }
            Console.WriteLine();

            Console.ReadLine();
        }
    }
}

Python 2 , 82 bytes

lambda n:`7*ord('L?J$rg$"79n*i.71&<B@[>)!Y8l:.pUo4GZ9c0a%'[n/2])`[n%2+1]

Pruébalo en línea!

Contiene algunos caracteres ASCII no imprimibles. flornquake ahorró dos bytes.

brainfuck , 402 bytes

--->+>->+>>+>+>>->->+>+>+>-->->+>+>>>->->+>+>>+>+>->+>>+>+>>+>->->>-->>>->+>>+>->->->->+>+>>->+>->+>>->>-->->>>->>>+>->->->->>->>+>-->+>+>+>>+>>>+>->->>+>>->->+>+>->>+>->->>+>->->++[[>+++<-]<+++]>>+>->+>>+>->+>+>+>+>+>+>+>+>->+>->+>>->->->>+>->->->->+>>->>>>+>+>+>>>+>>->+>>->+>->>->+>->+>>->>+>+>>+>+>+>->>>+>+>>>>+>->+>+>->+>+>>>->>>+>>>>+>->>>+>>>>->->->->->>+>,[<[-]>[<+>-]<-]++++[<+++++++++++>-]<.

Pruébalo en línea!

Ingresar como código de caracteres (por ejemplo, "A" = 65)

¡Pruébelo en línea con entrada de dígitos!

código:

build a value list (3217411852... reversed and each digit incremented by four)
--->+>->+>>+>+>>->->+>+>+>-->->+>+>>>->->+>+>>+>+>->+>>+>+>>+>->->>-->>>->+>>
+>->->->->+>+>>->+>->+>>->>-->->>>->>>+>->->->->>->>+>-->+>+>+>>+>>>+>->->>+>
>->->+>+>->>+>->->>+>->->++[[>+++<-]<+++]>>+>->+>>+>->+>+>+>+>+>+>+>+>->+>->+
>>->->->>+>->->->->+>>->>>>+>+>+>>>+>>->+>>->+>->>->+>->+>>->>+>+>>+>+>+>->>>
+>+>>>>+>->+>+>->+>+>>>->>>+>>>>+>->>>+>>>>->->->->->>+

>,                      get input
[                       while input > 0
  <[-]                      set next previous cell = 0
  >[<+>-]                   copy input cell to that cell
  <-                        and decrement it
]
++++[<+++++++++++>-]    add 44 to it
<.                      print it

Neim , 45 bytes

(₃β𝐒𝕣{𝕀𝔼𝐍N𝐭hj\CΓℚ𝕘𝕎𝐓φᚺ𝐲K$mᚠ"2𝕎oξ:{rm(𝕊/𝕚ᛂ𝐗})𝕕

Neim no está hecho para números decimales

Pruébalo en línea!

Befunge , 105 bytes

3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919&0g,@

No funciona en TIO porque parece ajustar líneas internamente a 80 caracteres por alguna razón. Puede hacer que funcione en TIO colocando cada dígito en una nueva línea y colocando el &0g,@después 3en la primera línea.

JavaScript (ES6) + mathjs , 78 bytes

(n,m=math.create({number:"BigNumber"}))=>`${n%2?m.e:m.pi}`.match(/\d/g)[n/2|0]

Cero indexado y funciona hasta 128 números (entrada máxima de 127).

Fragmento de prueba

let f=
(n,m=math.create({number:"BigNumber"}))=>`${n%2?m.e:m.pi}`.match(/\d/g)[n/2|0]

<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjs/3.16.0/math.min.js"></script>
<input type=number min=0 value=0 oninput="O.innerHTML=this.value.length>0?f(+this.value):''"><pre id=O>3

MATLAB (con caja de herramientas simbólica), 89 82 bytes

Al hacer uso de Symbolic Toolbox, esta respuesta proporciona una salida sin codificar los valores de pi y e.

Como un bono divertido, este código como entrada puede tomar un solo índice o una matriz de índices y proporcionará simultáneamente el valor de salida para todos los valores de índice proporcionados (por ejemplo, proporcionar 1:10 generará los primeros 10 valores).

a=char(vpa({'exp(1)';'pi'},51));
a(a=='.')=[];
n=input('');
a(9+fix(n/2)+56*mod(n,2))

^{(nuevas líneas agregadas para facilitar la lectura, no se requieren para la ejecución, por lo que no se incluyen en el recuento de bytes)}

Desafortunadamente, la versión Octave utilizada por TIO no admite entradas simbólicas a vpa función, por lo que no puede proporcionar en el enlace TIO.

En MATLAB, la indexación en el vector de retorno desde una función no es posible de la misma manera que con Octave, lo que significa que este es un programa completo en lugar de solo una función anónima. El programa solicitará una entrada ndurante la ejecución; este es un valor indexado para el cual se requiere el elemento. Al final del programa, el valor se imprime implícitamente.

Para el programa utilizamos la vpafunción que proporciona a 51 decimales el valor de piy exp(1)(e). Esto se hace simbólicamente para permitir una precisión teóricamente infinita. Para expandir más de 100 elementos, simplemente aumente el valor 51en el código para aumentar el rango.

Envolver vpaen char(es decir, char(vpa(...))) es necesario para convertir la salida de la función a una cadena en lugar de un valor simbólico. El resultado resultante es la cadena:

matrix([[2.71828182845904523536028747135266249775724709369996], [3.14159265358979323846264338327950288419716939937511]])

Esto incluye tanto e como pi con 51 decimales, lo suficiente para permitir 100 dígitos de nuestra salida (tenemos que hacer un poco de dp adicional de lo requerido para evitar imprimir valores redondeados)

Para poder indexar este lío, necesitamos al menos deshacernos de los puntos decimales para que ambas cadenas de dígitos sean contiguas. Originalmente utilicé un reemplazo simple de expresiones regulares de cualquier cosa que no sea un dígito sin nada. Sin embargo, puedo guardar 7 bytes al deshacerme del punto decimal usando el código:

a(a=='.')=[];

la cadena resultante es ahora:

matrix([[271828182845904523536028747135266249775724709369996], [314159265358979323846264338327950288419716939937511]])

Contiene todos los dígitos que necesitamos con fragmentos pi y e en índices consecutivos.

Luego podemos convertir el índice proporcionado de modo que los números impares accedan al fragmento pi y los números pares accedan al fragmento e utilizando el cálculo:

9+fix(n/2)+56*mod(n,2)

Acceder a ese (esos) índices (índices) en la cadena anterior proporcionará la salida correcta.

Axioma, 148 bytes

g(x,n)==floor(numeric(x)*10^n)::INT rem 10
f(n:NNI):NNI==(m:=digits((n+4)::PI);x:=n quo 2;if n rem 2=1 then r:=g(%e,x)else r:=g(%pi,x);digits(m);r)

Matriz basada en 0. Resultados

(10) -> [f(i) for i in 0..20]
   (10)  [3,2,1,7,4,1,1,8,5,2,9,8,2,1,6,8,5,2,3,8,5]
                                            Type: List NonNegativeInteger
(11) -> f(100001)
   (11)  6
                                                    Type: PositiveInteger

Hojas de cálculo de Google, 47 bytes

Nota: debido a la longitud de las constantes almacenadas en Excel y Google Sheets, esta solución solo tiene una precisión de 20 dígitos, en consecuencia

Función de hoja de trabajo anónima que toma la entrada de la celda A1y emite ese dígito de Pie a la celda que llama

=Mid(.1*If(IsOdd(A1),Pi(),.1*Exp(1)),3+A1/2,1

Versión codificada, 112 bytes

Esta versión cumple totalmente con las especificaciones del programa, pero generalmente no es divertida.

Función de hoja de trabajo anónima que devuelve el enésimo dígito en la lista de pie indexada en 1

=Mid("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1

BFASM , 142 bytes

stk 0
org 0
txt "3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"
in_ r1
rcl r2, r1
fuera r2

Toma la entrada como carácter ascii, da salida en forma de dígito.