Tout le monde connaît pi la constante mathématique, le rapport entre la circonférence d'un cercle et son diamètre.

3.14159265358979323846264338327950288419716939937510...

Vous savez probablement aussi e la constante mathématique, la base d'un logarithme naturel.

2.71828182845904523536028747135266249775724709369996...

Mais ... tu connais la tarte ? C'est l'une des constantes les plus importantes (pour moi). Ce sont les chiffres de pi et e entrelacés.

32.1741185298216852385485997094352233854366206248373...

En tant qu'expansion décimale:

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

Ceci est la séquence OEIS A001355 .

MOT-CLÉ: non, base, bête , facile

C'est une séquence très stupide.

Défi

Ecrivez un programme / fonction qui prend un entier non négatif n et génère le nième chiffre du camembert .

Caractéristiques

• Les règles d'E / S standard s'appliquent .
• Les échappatoires standard sont interdites .
• Votre solution doit travailler pendant au moins 50 chiffres de chaque constante qui signifie qu'il devrait fonctionner pendant au moins 100 termes de la séquence (s'il vous plaît, essayez de ne pas hardcode: P).
• La sortie pour 2 ou 3 n'est pas un point décimal .
• Votre solution peut être indexée 0 ou indexée 1 mais veuillez préciser laquelle.
• Ce défi ne consiste pas à trouver l'approche la plus courte dans toutes les langues, mais plutôt à trouver l' approche la plus courte dans chaque langue .
• Votre code sera noté en octets , généralement dans le codage UTF-8, sauf indication contraire.
• Les fonctions intégrées qui calculent cette séquence sont autorisées, mais il est vivement conseillé d'inclure une solution qui ne repose pas sur une fonction intégrée.
• Les explications, même pour les langues "pratiques", sont encouragées .

Cas de test

Ceux-ci sont indexés par 0.

Input   Output

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

Dans quelques meilleurs formats:

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 octets

1 indexé

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

Haskell, 154 147 146 octets, AUCUN HARDCODAGE OU UTILISATION DE CONSTANTES BUILTIN

Cette solution calcule e et pi en utilisant des séries infinies et les stocke dans des entiers à virgule fixe de précision arbitraire ( Integertype intégré de Haskell et son Rationalextension).

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

Ungolfed:

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 indexé. Précis pour l'entrée 0-99, inexact pour l'entrée 100-101, en dehors des limites sinon.

Explication:

Calcule pi en utilisant cette série infinie . Calcule e en utilisant la série factorielle inverse classique . Théoriquement, ce ne sont pas les formules idéales à utiliser, car elles ne sont pas très concises en termes de décompte, mais ce sont les seules que je puisse trouver qui convergent assez rapidement pour permettre la vérification de la précision (d'autres sommes requises des centaines de milliers si pas des millions de termes). Dans la version golfée, e est calculé avec une précision bien supérieure à celle nécessaire pour minimiser les sous-comptages. Les deux constantes sont calculées avec un nombre de chiffres légèrement supérieur au nombre nécessaire pour éviter les erreurs d'arrondi (responsables de la queue peu commode des valeurs incorrectes).

Les constantes sont calculées en tant que ratios entiers de précision arbitraire ( Rational), puis multipliées par 10 ^ 50 de sorte que tous les chiffres nécessaires restent intacts lorsque le rapport est converti en un entier (précision arbitraire) ( Integer). Cela évite également le problème du point décimal dans les représentations sous forme de chaîne de nombres, que la fonction tire alternativement des caractères.

Taxi , 749 octets

'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.

Essayez-le en ligne!

Essayer de calculer pi ou e par programme dans Taxi serait un cauchemar, même si je suis sûr que cela peut être fait. Ainsi, il est beaucoup plus court de simplement coder en dur les 100 premiers chiffres de la séquence. Cela semble assez bon marché, mais c’est certainement le code de taxi le plus court qui soit.

Il code la séquence en tant que chaîne , en prend n, puis itère nvers le bas et supprime le premier caractère de la chaîne à chaque fois. When n=0, affiche le premier caractère. Ceci est un indexé.

Non-golfé / formaté:

'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 octets

-4 octets grâce à l'idée de conversion de base de @EriktheOutgolfer .

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

Essayez-le en ligne!

Python 2 + sympy , 92 octets

0 indexé. Merci à Rod pour m'avoir rappelé de passer à from sympy import*, ce que j’avais oublié.

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

Essayez-le en ligne!

Python 2 , 114 octets

Honnêtement, je pense que la solution la plus courte est le codage en dur, car Python n’a pas de fonctions intégrées utiles.

lambda n:"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Essayez-le en ligne!

Python 2 , 114 octets

Solution équivalente de @totallyhuman .

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919'.__getitem__

Essayez-le en ligne!

05AB1E , 10 octets

žsтžtøJþsè

Explication:

ž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 indexé.

Essayez-le en ligne!

Python 3 , 83 80 octets

0 indexé.

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

Essayez-le en ligne!

Il contient des caractères non imprimables qui ne peuvent pas être vus correctement dans un navigateur.

Cela fonctionne en construisant le tuple à (32, 17, 41, 18, 52, ...)partir des codes ASCII des caractères de la chaîne d'octets codée en dur. Le tuple est converti en chaîne '3217411852...', à partir de laquelle nous sélectionnons le bon chiffre.

Polyglotte, 108 octets

n=>"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Travaille dans:

• C #
• JavaScript

Je pense que c’est le plus court que vous puissiez faire en C # car il faut 252 octets pour trouver la Nième décimale de pi .

Java 8, 420 417 413 404 380 358 (calculé) & 115 110 octets (codé en dur)

Calculé ( 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);}

Essayez ici.
Prouvez que le résultat correct est obtenu pour les 100 éléments requis.

Codé en dur: ( 115 110 octets ):

"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"::charAt

Essayez-le en ligne.

0 indexé

-9 et -5 octets grâce à @Nevay .
-24 octets grâce à @ceilingcat .

• Votre solution doit travailler pendant au moins 50 chiffres de chaque constante qui signifie qu'il devrait fonctionner pendant au moins 100 termes de la séquence (s'il vous plaît, essayez de ne pas hardcode: P)
• Les fonctions intégrées qui calculent cette séquence sont autorisées, mais il est conseillé d'inclure une solution qui ne repose pas sur une fonction intégrée.

Vous l'avez demandé ..;)

Les doubles Math.PIet les éléments intégrés de Java Math.Eont une précision maximale de 16. Par conséquent, nous devrons calculer les deux valeurs nous-mêmes en utilisant java.math.BigIntegeret / ou java.math.BigDecimal.
Depuis que j'ai déjà calculé PI auparavant dans un autre défi , j'ai utilisé ce même code en utilisant BigInteger. L'algorithme pour le nombre d'Euler utilise BigDecimalcependant.
Le résultat pet esont donc: 31415...et 2.718....

Pouvait probablement jouer au golf en utilisant seulement BigDecimal, mais donnait des réponses incorrectes pour PI, alors j’utilise maintenant les deux BigDecimalet BigInteger.

Explication:

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

Graine , 6015 octets

105 41100973201674650461227976639700390615120600528953176107701316721890649738810349651490948904154731057172335535600875054878204557287393379815378680878571406244365932330202793040308312687924242319799562985464135998860369933720376853281630432469462831217924775601393232895404104191613314969008627719099002734936685651970933027922574843126481552407811220371545812798263882325951724505132794956253992779856191832909434513683936955184871247159313261417328850445886987045814618325821125417040265540589403338721758954467831926977078444612065747526326682314711350486782090838673475876960125016098416460032667015813053483457246043486676622061645094043655351781242050448580132075920324099742699960838361839038297355120817832056960516761862493176616153258281345538652844974811030063414112136642097000574165433957710342430709643110444042577685157477268110199017600011209827070311299268347100419887111107237908884608557593677163764286026624394674781868689858494991328505977301270068505397030743037416430245399054325956185200430657008806539374392625804513081295070438243600044274289109395357299275275193717501822777898664715885427884193864182834402097958423697356485767670945673525604620701482288023981110598866625872386643941558021439168402392304238271452444124214301243311025121833097491087918320170873313832323794851508364788578530614246140801266858481189449278157296335592848066512127882306035576754122325822200069362884409931190620435627809384380203617488253034370361172908245852012086081807945576657014184275798330804532115103840313004678040210379846666674881048346897213048386522262581473085489039138251061251160730845385869281787222083186331344552658814775998639661361866503862291670619153718574270905089351133527806484519543645501497150560454761284099358123613642350160410944676702481576280832672884549762767667090615809061739499629798396737503512011645776394176807352443544839957773371384141101627375926404212619777658374366513665083032140398814384622434755543347503025479743718569310129255927244046638238401670388409731849963600790867434678993019370132638962549859363736476668247251402420832876258626149639101811361047924632565285870213656416957893835899254928237592711662454838295046528789720146967061486405916116778722736283489123195985053535189375957277052428901645131462087039117212488839670735246752589931585405440449333046667938628384693216121067951290025349082277568986632815062532963505690244579740140120806885104683071514922412748240497612209609661707922754236180441892543545377867355182682381812487973645406703590150722720330526173957597156314579144484166520730013480681064941752984345205140917291104888971742824066713606933406657345121342075268990055328274845008936364502884461548416337689565392911129757761902576946104722487260155373897552821908338346641549478063474748830482136404008215583192489320750526753663943267086203954602839906762640389978523894333743126288529975769945319614142422443068420170103245659109689433597701350198280212250954698442638475209618790055335813263132865176791663235801963797561493995544185124734214257034901773781134331460320221759556924556747571745834582344275416625351302153332814233497096345055392255809024712740720006219615340819493781244665414077298346378966540544979367367978334759985048507214749726072645238624803791884339024844989975370042133733339339038567691571361407296615851372112592532463329778465699812822089846474961581380707849259093905314170108054540333209088059730272087864344697983074458088984533095183089310714804468718319244214535941276969904638763288063417624586766891798378622613765728303031397998644194508610598078718347204813844240434145846888722334194516524032354042557957058092854659539699310565707914118281251563405735083553254856313838760124953245573676126601070861004186509621892263623745673900572829301771299438501543213489182375655869072568437776298051260531944785904157204006430131566234389896821642210616326951771496269255716808352415001187083781128619236455170025989777631182990311607133740812107138446626302353752098982590371714623080450836912706275397973009559314275978915463843159370230629290376520494894845680706499809017211545204670148071902560908658269183779180493590025891585269507219866461550160579656755846447951259951641828495549544791046179035585611272240116822105364823082512055639047431280117805724371019657801828634946412396263504315569042536942671358095826696817513115447079645898107923447321583282886740680340887700198072304400536529418546232473450984945589794448490331085275232352881571706521961358975744067916422124670374397682877259664913100427726059898474024964867713698696116581478101206003313106174761699804016604950094008714907179862448792216891309734208815522069346791369498202430302292199779590583788518283934542807403049256936179914953814019565550264909025345322516061595136601312434888871667940394250767164496543418483237896796108764367721411969986710930448108645039275082356457263454340220118278471652962484104099512207532103709146426640958406853240342441810465024550617909657901698718289260589269758398513490424434162831332785821428006396653475356712733072469052427934231406388810607688824035522285626563562286337967271308076321307276537761026788485320280603487776428017017298356181654076403306265118978333909378403193559129146468182910851996415072056976175613473847242292911071040966109905552914332596680497156169349277079292398091020434667210493868422848588893205157133171899819212153010393580099455957808703428739456223073813663954919146593698106305501988107196273527346690785289909397140611634970017071011599022429384594426022933102487171920965595473754661194965266230932928905708783854897164127767575976566931916632077914904360565095752466049885656187054491320449776951484812738806536727562344348761718424255018794271994537719709226236497935053971406685810778014002594041715040546776952342303797267458880802314841325359844565479173256964507237937290466116935912176054052746039378370966040054779443633371806403649852746347690237831260027483859907620684197542069045517397230169577918374265220969534695931904

L'équivalent de graine à ma réponse Befunge. Comme je l'ai déjà mentionné, le programme Befunge dont les sorties ne fonctionnent pas sur TIO, car celui-ci semble avoir un retour à la ligne interne de 80 caractères.

Excel, 113 octets

1 indexé

=MID("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1)

PI()n'est précis que jusqu'à 15 chiffres. Similaire pour EXP(1).

60 solution de 42 octets qui fonctionne pour Input <=30 (-18 octets grâce à @Adam)

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

05AB1E , 13 octets

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

Essayez-le en ligne!

Semblable à la réponse de Magic, mais un peu différent.

Explication:

É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 octets

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

Essayez-le en ligne!

Japt , 55 octets

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

Testez-le en ligne! Contient quelques imparfaites.

Fonctionne en remplaçant chaque caractère de la chaîne par son charcode, puis en renvoyant le chiffre au bon index. La chaîne a été générée par ce programme:

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

Testez-le en ligne!

Julia, 63 octets

1 indexé

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

Convertit pi ou e en chaîne, supprime la décimale, puis appelle le chiffre approprié. Retourne une représentation en caractères du chiffre.

Semence, 5852 5794

Basé sur la réponse TehPers Befunge.

1051130021648715907393149878290493079600376561988348664272369051219541158034251323778110172612675089859184605166991106040693833909592598132115295033728752738087105881243462563076466678196376225832661747114302365429787133716511111381612588140144307910362782924144996564529411691568302571546828919454271683233497896594149189544327214969302848984257909609092418942847813158570493297692245428646803536815345759334224247677074872671057296478697076157019699466324478990259351466108726578472175001474585821629778406880297836753303012207209976229264609834293181367664486642493394085473509253813676093779567738697465957519812706192139261472118908699638816640825554051850436762061721281771892466822470585742923158999350909054375916612667405594051622229969696110285582900916410099224974902720736021096981441362371398922887585642863359978062601767338412679956208026294953110185271056006145171920926497396179933553547647876354874445336583594285656870801545177578902705927733720249211636847884869491097054175976937629709200212494761217184873108852140655722895359613462156833646123152648220793295854627649452190956799160703532861477096009725706141202331131287901266622861560576869037209421378739125115765163010112273561384890274706972479335859548424507413589440122160717697618157336618754196528390529316634155057447126317467878320143220148685911507025731721669456692292309133633447284353130542004299981319048073637696567634889623949341630372505055435189663767044165063763216111834588696399179737702861529836947970901482712510136315042152110633215913241916694919566433112405210063414042670097562256073600916103886503591248191758835092924394147776204171675226850914902590401360360345796925181247981647089261884952039081268986586818659090505317955579671089885915745568661758883469031230794272571159213300281445730703294269295310767401339422952480777920786878410780792687195268799097885426801795242758273587841272731685278721369746727313447085996142152811199340656395207452343492937579702451111716453371016654791322834865918860033642314402995240481293652425792697358895577606699947511030416728684352022506710677976841690749387202992493347056114389784733211172448656007595582911222364847293116425714996343958156522448560363063094260073906846664112391722958505451464414025605603413323283807093107521955579711235903403153357003170132938512689946882757999117710160645821945148763813674548797981224375547254576063310479473749044201972863935442758458424285806147218666471747061869918574545072745631758049982372007444866300485095061433951914878373501952670216546435388818497342311417254246013304856715094953051481317438104933875171470343900106719705171102058673610594748846178562080370992488881764909402902065625464750558527389775735939044400858705229893243673486621988009838791971714603625037310885148140796813757120291067372196872928228321095156712054303101901959874384063672886495472796070113365603843687513322867176197917489855537726934095360491472497352567147140246395682503059404971449739625647398820598964158265302668783916501984956044969021302601920487717382879106303683795359905325347814473318519391344565458920270463279174784746656360314070464241666622240210385245184959282222666398870656274940629675453574246097799383361429014800618720780346294542185892116417842240524776835458087900018007896901140383243611793705883547791450682392261960643824271328189332116466519255567441515615925840284456154022304291978218634565379575148642711337622789721842048696443945213454162713556316912301346193615227854869318871089808249776555077834342492281888561676171087168150941237306007109521081900169693331625918138699682645157924632842546989812618292449480799580909720292280095095845962850721356554807680991288722147671740885576811339492549454926901594927338274410385863276725958781460924134466358260089533908525106740467122470973368676988277207568882122479840074670300214980511007665457235218290742394089204192282508491125777180151491866961638111244962953268398339686189772372983926068579350047402754803068232034594024872791141428095120311259087973136353149728638143035136784730999270266072749004567217555438270988124997549762230020689881669285499865374963053282530118570884108038975805335341098720577305266629567047445192403700472887794782423940658412176424370062158626834653405675401415679083822191617061925174149189203359499283160374801737260780407460559147326758994495549579747033361234471750470244513311080274649191860724511086222353696966556035904101416366866518427071604705222938635947781869520181137451408849640159586041113639598272540062185768190959707775362176381804238896341317485410279831458927597060094913931822437950489034755418876566165098609145551163170170060968550804192429683076682433548504113044161906874992120619724109268394986529182050977866104283639955069424323124118234270471868688405770066267298550544345355480568344482162465184049105391961294335245926910436280167548428908725073049063187423431751542064521517069452498182346407984197390998799924644160478679731476796691938148057603728267749331459031937823996495889234787060791079241854542581243078812931046333013380737766914161425371301455762684652883345176576166320850926855173197613536554369628772428747263956045786416295429184651985570482338242016559363725421100270243627030197439290918962948652873397874243832067459791837014394278403085907234616003231621600132126403225123227458214686006897240158060744989458215243787817148717936756981074208678765977744940577875579654698779849605118845010395906232293740180888137656291524050590071724242335942378834532707622396324405477279768052696927856056064019532570357101573277570040254706775462396160275876038886428146097798897998315086627358220951838049046100218938610753230860169099104474379950181692561834872540511195903774693113510283120187768500261160296892119883913289017641545057765550924909632887927659777449405778755796546987798496051188450103959062322937401808881376562915240505900717242423359423788345327076223963244054772797680526969278560560640195325703571015732775700402547067754623961602758760388864281460977988979983150866273582209518380490461002189386107532308601690991044743799501816925618348725405111959037746931135102831201877685002611602968921198839132890176415450577655509249096328879276597774494057787557965469877984960511884501039590623229374018088813765629152405059007172424233594237883453270762239632440547727976805269692785605606401953257035710157327757004025470677546239616027587603888642814609779889799831508662735822095183804904610021893861075323086016909910447437995018169256183487254051119590377469311351028312018776850026116029689211988391328901764154505776555092490963288792

Malbolge Unshackled (variante de rotation de 20 bits), 3,64E6 octets

La taille de cette réponse étant supérieure à la taille maximale du programme (eh), le code est situé dans mon référentiel GitHub (note: ne copiez pas le code avec CTRL + A et CTRL + C, cliquez avec le bouton droit de la souris sur "Enregistrer l'élément de destination sous". .. ").

Comment faire ça?

Cela pourrait être une partie délicate, car un interprète naïf de Haskell mettra des siècles à faire la différence. TIO a un interprète décent Malbogle Unshackled, mais malheureusement, je ne pourrai pas l'utiliser (limitations).

Le meilleur que j'ai pu trouver est la variante de largeur de rotation fixe de 20 trit, qui fonctionne très bien, calculant (à peu près) instantanément .

Pour rendre l'interprète un peu plus rapide, j'ai supprimé toutes les vérifications de l'interprète 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 octets

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

Essayez-le en ligne!

Cette réponse est indexée par 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 octets

0 indexé Essayez-le en ligne!

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

Battez le codage dur par 5 octets !! Mais pourrait probablement être mieux. Mais battre le codage en dur me fait du bien :)

Pyth, 35 octets

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

Suite de tests

Puisque Pyth n'a pas de constantes pi et e de précision arbitraire intégrées, je les calcule directement.

Calculer pi:

u+/*GHhyHyK^T99rJ^2T0

Il utilise la récurrence suivante fraction continue de calculer pi: 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + ...)))). Je l'ai eu d' une autre réponse PPCG . Il est dérivé dans les équations 23-25 ici .

Je le calcule de l'intérieur, en omettant tous les termes au-delà de la 1024e, car les derniers termes ont peu d'effet sur le nombre, et je maintiens une précision de 99 chiffres pour m'assurer que les 50 premiers sont corrects.

Calculer e:

sm/K.!dJ

Je fais la somme des inverses des 1024 premiers nombres, à 99 chiffres de précision.

Ensuite, je convertis les deux nombres en chaînes, les entrelace et les index.

MATLAB, 93 octets

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

Une explication simple est que ceci convertit d’abord e et pi en chaînes, puis passe par une boucle for concaténant les chiffres. Ici, c est pie, p est pi et e est e.

J'ai également divisé cette information en plusieurs lignes pour en améliorer la lisibilité, mais le code actuel est sur une seule ligne avec un espacement minimal.

C # + BigDecimal , 377 372 octets

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

5 octets sauvegardés grâce à @ Kevin Cruijssen.

Pas de lien TIO à cause de la bibliothèque externe, malheureusement, C # n’a pas de BigDecimalclasse intégrée , donc cette externe devra le faire. Il est probablement encore possible de jouer au golf, mais pas pour le moment.

Version complète / formatée:

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 octets

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

Essayez-le en ligne!

Contient des caractères ASCII non imprimables. flornquake a économisé deux octets.

brainfuck , 402 octets

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

Essayez-le en ligne!

Saisir comme code de caractère (par exemple "A" = 65)

Essayez-le en ligne avec saisie numérique!

code:

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 octets

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

neim n'est pas fait pour les nombres décimaux

Essayez-le en ligne!

Befunge , 105 octets

3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919&0g,@

Ne fonctionne pas sur TIO car il semble que les lignes soient internes à 80 caractères pour une raison quelconque. Vous pouvez le faire fonctionner sur TIO en plaçant chaque chiffre sur une nouvelle ligne et en plaçant &0g,@après le 3sur la première ligne.

JavaScript (ES6) + mathjs , 78 octets

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

Zéro indexé et fonctionne jusqu'à 128 nombres (entrée maximum de 127).

Test Snippet

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 (w / Symbolic Toolbox), 89 82 octets

En utilisant la boîte à outils Symbolic, cette réponse fournit une sortie sans coder en dur les valeurs de pi et e.

En tant que bonus amusant, ce code en tant qu’entrée peut prendre soit un index unique, soit un tableau d’index et fournit simultanément la valeur de sortie pour toutes les valeurs d’index fournies (par exemple, fournir 1:10 affichera les 10 premières valeurs).

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

^{(nouvelles lignes ajoutées pour la lisibilité, non requises pour l'exécution, donc non incluses dans le nombre d'octets)}

Malheureusement, la version Octave utilisée par TIO ne prend pas en charge les entrées symboliques de la vpafonction et ne peut donc pas fournir de lien à TIO.

Dans MATLAB, l'indexation dans le vecteur de retour d'une fonction n'est pas possible de la même manière qu'avec Octave, ce qui signifie qu'il s'agit d'un programme complet plutôt que d'une simple fonction anonyme. Le programme demandera une entrée nlors de l'exécution - il s'agit d'une valeur indexée pour laquelle l'élément est requis. A la fin du programme, la valeur est implicitement imprimée.

Pour le programme, nous utilisons la vpafonction qui fournit à 51 décimales la valeur de piet exp(1)(e). Ceci est fait symboliquement pour permettre une précision théoriquement infinie. Pour développer plus de 100 éléments, augmentez simplement la valeur 51dans le code pour augmenter la plage.

Le retour vpaà la ligne char(ie char(vpa(...))) est nécessaire pour convertir la sortie de la fonction en chaîne plutôt qu'en valeur symbolique. Le résultat obtenu est la chaîne:

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

Cela inclut les e et les pi jusqu'à 51 décimales - assez pour permettre 100 chiffres de notre sortie (nous devons faire un peu plus de dp que nécessaire pour éviter d'imprimer des valeurs arrondies)

Afin d'indexer dans ce désordre, nous devons au moins nous débarrasser des points décimaux pour que les deux chaînes de chiffres soient contiguës. À l’origine, j’utilisais un simple remplacement regex de tout ce qui n’était pas un chiffre sans rien. Cependant, je peux économiser 7 octets en supprimant uniquement le point décimal à l'aide du code:

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

la chaîne résultante est maintenant:

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

Il contient tous les chiffres dont nous avons besoin avec les morceaux pi et e dans les index consécutifs.

Nous pouvons ensuite convertir l'index fourni de sorte que les nombres impairs accèdent au bloc pi et que les nombres pairs accèdent au bloc e en utilisant le calcul

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

Accéder à cet index (ces index) dans la chaîne ci-dessus fournira la sortie correcte.

Axiome, 148 octets

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)

0 tableau basé. Résultats

(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

Google Sheets, 47 octets

Remarque: en raison de la longueur des constantes stockées dans Excel et Google Sheets, cette solution n’est précise qu’à 20 chiffres, en conséquence.

Fonction de feuille de travail anonyme qui prend en entrée une cellule A1et envoie ce chiffre de Pie à la cellule appelante

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

Version codée en dur, 112 octets

Cette version répond parfaitement aux spécifications du programme, mais n’est généralement pas amusante.

Fonction de feuille de travail anonyme qui renvoie le nième chiffre de la liste de camembert indexée 1

=Mid("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1

BFASM , 142 octets

stk 0
org 0
txt "321741185298216852385485997094352233854366206248373487312375925602284894717951212494930309336795919"
in_ r1
rcl r2, r1
out r2

Prend la saisie sous forme de caractère ascii, donne la sortie sous forme de chiffre.