Mélanger pi et e pour faire la tarte!

37

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
totalement humain
la source
8
Selon OEIS, le mot clé dumbsignifie simplement inintéressant, sans propriétés particulières.
Okx
1
@Downvoter Une raison, peut-être?
totalement humain
27
On pourrait dire que le résultat est pei, nonpie
Zaid
1
Je n'ai pas voté à la baisse, mais peut-être parce que vous ne l'avez pas posé la question le 3/14;)
txtechhelp
1
À 13h59, @txtechhelp? ;)
WallyWest

Réponses:

12

Mathematica, 50 octets

1 indexé

(Riffle@@(#&@@RealDigits[#,10,5!]&/@{Pi,E}))[[#]]& 
J42161217
la source
Pouvez-vous expliquer comment cela fonctionne?
Stevoisiak
c'est facile. Il faut 120 (5!) Éléments de chacun et les
échafauder
Agréable! J'ai essayé de vaincre votre solution en évitant Riffle, mais ma solution est un octet court: RealDigits[If[OddQ@#,Pi,E],10,#][[1,Ceiling[#/2]]]&
Mark S.
Cela semble ne pas fonctionner. Il retourne un seul chiffre.
DavidC
@DavidC Yes! .. "affiche le nième chiffre de la tarte" Exactement! pourquoi as-tu voté vers le bas ???
J42161217
9

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.

ApprocherDarknessFish
la source
8

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.
Rôti d'ingénieur
la source
6

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!

M. Xcoder
la source
Avant de voter, prenez votre temps pour rechercher une solution plus courte.
M. Xcoder
@totallyhuman Merci
M. Xcoder
8
La solution équivalente que vous avez modifiée est en réalité un code équivalent, et non un nombre d'octets équivalent. : P
totalement humain
1
@totallyhuman Lol J'ai vu votre commentaire et je l'ai compris, mais j'ai complètement oublié de réparer parce que je riais de ma propre erreur. Merci pour l'édition!
M. Xcoder
5

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!

Okx
la source
1
Trop de 05AB1Es ...: P
M. Xcoder
@ Mr.Xcoder Eh bien, 05AB1E est la langue avec le pi et e intégré ...
Okx
@ Mr.Xcoder Il y a des éléments intégrés pour cette raison.
Erik l'Outgolfer
@totallyhuman non, ce n'est pas le cas.
Erik l'Outgolfer
@Dorian Votre version ne fonctionne pas. Vous utilisez l'ancienne version, mais žtvous n'étiez pas une liste infinie à l'époque, c'est pourquoi Okx utilise les 100 premiers chiffres de e dans son programme. Le changer pour la nouvelle version de 05AB1E (où pi et e sont tous deux une liste infinie) ne fonctionnerait toujours pas dans votre version actuelle, car le zip créerait des paires et le Join joindrait ces paires au lieu de tout. 9 octets sont encore possibles en remplaçant Jpar Sdans la nouvelle version, mais en Sfont une liste aplatie de caractères / chiffres
Kevin Cruijssen
5

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.

flornquake
la source
4

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 .

TheLethalCoder
la source
JS polyglot :-)
Arnauld
@Arnauld Mis à jour :)
TheLethalCoder
7
Ce n'est pas un polyglotte Java! Vous ne pouvez pas indexer dans des objets non-tableaux en Java.
Roman Gräf
1
Techniquement, cela fonctionne, mais j’ai voté contre parce que c’est a) pas très compétitif et b) extrêmement ennuyeux et trivial.
HyperNeutrino
4
@HyperNeutrino C'est C # et JavaScript quand sont-ils compétitifs? Et ennuyeux et trivial peut-être, mais préférez-vous que je fasse une réponse de 500 octets en C # qui soit intelligente? Non, parce que cela entre en conflit avec le point 1. C'est aussi court que cela ...
TheLethalCoder
4

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
Kevin Cruijssen
la source
Je ne sais pas si cela vous aidera, mais mon algorithme de calcul de pi en C # est arrivé à 8 octets de moins que votre version de Java.
TheLethalCoder
Notez bien que pour que cela fonctionne correctement pour cette question changer (d+=2)pour ++det return p%10+1juste return p%10.
TheLethalCoder
@TheLethalCoder N'hésitez pas à donner une réponse en C # à ce défi. :) Bien que vous deviez également calculer le nombre d'Euler. Ma réponse est un peu pour lolz de toute façon, puisque la sortie en codage en dur est plus courte de toute façon ..
Kevin Cruijssen
1
You've asked for it.. ;)Hey, j'aime mieux votre premier. J'ai eu beaucoup plus de réponses codées que je ne pensais ...
totalement humain
1
Vous pouvez économiser 9 octets dans votre réponse calculée en utilisant charAt(n+1>>1)et 5 octets dans votre version codée en dur en utilisant une référence de méthode "..."::charAt.
Nevay
3

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.

TehPers
la source
Comment? Juste comment?
NieDzejkob
1
codegolf.stackexchange.com/a/193325/61379 Outgolfed
Krzysztof Szewczyk
3

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)
Wernisch
la source
Le concept de base de votre seconde approche peut être réduit à 46 octets en n'inscrivant que le choix de choix dans la if(...)déclaration: =MID(IF(ISODD(b1),PI(),EXP(1)/10)/10,b1/2+3,1).Vous ne pouvez pas contourner l'imprécision de pi()et exp(), cependant
Adam
2

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]
Erik le golfeur
la source
2

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!

ETHproductions
la source
2

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.

Ben
la source
1
Bienvenue chez PPCG!
Martin Ender
2

Semence, 5852 5794

Basé sur la réponse TehPers Befunge.

1051130021648715907393149878290493079600376561988348664272369051219541158034251323778110172612675089859184605166991106040693833909592598132115295033728752738087105881243462563076466678196376225832661747114302365429787133716511111381612588140144307910362782924144996564529411691568302571546828919454271683233497896594149189544327214969302848984257909609092418942847813158570493297692245428646803536815345759334224247677074872671057296478697076157019699466324478990259351466108726578472175001474585821629778406880297836753303012207209976229264609834293181367664486642493394085473509253813676093779567738697465957519812706192139261472118908699638816640825554051850436762061721281771892466822470585742923158999350909054375916612667405594051622229969696110285582900916410099224974902720736021096981441362371398922887585642863359978062601767338412679956208026294953110185271056006145171920926497396179933553547647876354874445336583594285656870801545177578902705927733720249211636847884869491097054175976937629709200212494761217184873108852140655722895359613462156833646123152648220793295854627649452190956799160703532861477096009725706141202331131287901266622861560576869037209421378739125115765163010112273561384890274706972479335859548424507413589440122160717697618157336618754196528390529316634155057447126317467878320143220148685911507025731721669456692292309133633447284353130542004299981319048073637696567634889623949341630372505055435189663767044165063763216111834588696399179737702861529836947970901482712510136315042152110633215913241916694919566433112405210063414042670097562256073600916103886503591248191758835092924394147776204171675226850914902590401360360345796925181247981647089261884952039081268986586818659090505317955579671089885915745568661758883469031230794272571159213300281445730703294269295310767401339422952480777920786878410780792687195268799097885426801795242758273587841272731685278721369746727313447085996142152811199340656395207452343492937579702451111716453371016654791322834865918860033642314402995240481293652425792697358895577606699947511030416728684352022506710677976841690749387202992493347056114389784733211172448656007595582911222364847293116425714996343958156522448560363063094260073906846664112391722958505451464414025605603413323283807093107521955579711235903403153357003170132938512689946882757999117710160645821945148763813674548797981224375547254576063310479473749044201972863935442758458424285806147218666471747061869918574545072745631758049982372007444866300485095061433951914878373501952670216546435388818497342311417254246013304856715094953051481317438104933875171470343900106719705171102058673610594748846178562080370992488881764909402902065625464750558527389775735939044400858705229893243673486621988009838791971714603625037310885148140796813757120291067372196872928228321095156712054303101901959874384063672886495472796070113365603843687513322867176197917489855537726934095360491472497352567147140246395682503059404971449739625647398820598964158265302668783916501984956044969021302601920487717382879106303683795359905325347814473318519391344565458920270463279174784746656360314070464241666622240210385245184959282222666398870656274940629675453574246097799383361429014800618720780346294542185892116417842240524776835458087900018007896901140383243611793705883547791450682392261960643824271328189332116466519255567441515615925840284456154022304291978218634565379575148642711337622789721842048696443945213454162713556316912301346193615227854869318871089808249776555077834342492281888561676171087168150941237306007109521081900169693331625918138699682645157924632842546989812618292449480799580909720292280095095845962850721356554807680991288722147671740885576811339492549454926901594927338274410385863276725958781460924134466358260089533908525106740467122470973368676988277207568882122479840074670300214980511007665457235218290742394089204192282508491125777180151491866961638111244962953268398339686189772372983926068579350047402754803068232034594024872791141428095120311259087973136353149728638143035136784730999270266072749004567217555438270988124997549762230020689881669285499865374963053282530118570884108038975805335341098720577305266629567047445192403700472887794782423940658412176424370062158626834653405675401415679083822191617061925174149189203359499283160374801737260780407460559147326758994495549579747033361234471750470244513311080274649191860724511086222353696966556035904101416366866518427071604705222938635947781869520181137451408849640159586041113639598272540062185768190959707775362176381804238896341317485410279831458927597060094913931822437950489034755418876566165098609145551163170170060968550804192429683076682433548504113044161906874992120619724109268394986529182050977866104283639955069424323124118234270471868688405770066267298550544345355480568344482162465184049105391961294335245926910436280167548428908725073049063187423431751542064521517069452498182346407984197390998799924644160478679731476796691938148057603728267749331459031937823996495889234787060791079241854542581243078812931046333013380737766914161425371301455762684652883345176576166320850926855173197613536554369628772428747263956045786416295429184651985570482338242016559363725421100270243627030197439290918962948652873397874243832067459791837014394278403085907234616003231621600132126403225123227458214686006897240158060744989458215243787817148717936756981074208678765977744940577875579654698779849605118845010395906232293740180888137656291524050590071724242335942378834532707622396324405477279768052696927856056064019532570357101573277570040254706775462396160275876038886428146097798897998315086627358220951838049046100218938610753230860169099104474379950181692561834872540511195903774693113510283120187768500261160296892119883913289017641545057765550924909632887927659777449405778755796546987798496051188450103959062322937401808881376562915240505900717242423359423788345327076223963244054772797680526969278560560640195325703571015732775700402547067754623961602758760388864281460977988979983150866273582209518380490461002189386107532308601690991044743799501816925618348725405111959037746931135102831201877685002611602968921198839132890176415450577655509249096328879276597774494057787557965469877984960511884501039590623229374018088813765629152405059007172424233594237883453270762239632440547727976805269692785605606401953257035710157327757004025470677546239616027587603888642814609779889799831508662735822095183804904610021893861075323086016909910447437995018169256183487254051119590377469311351028312018776850026116029689211988391328901764154505776555092490963288792
Krzysztof Szewczyk
la source
Bon travail! Je suis un peu curieux de savoir comment vous avez joué au golf.
TehPers le
2

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;
}
Krzysztof Szewczyk
la source
Cela ressemble à plus de 3646 octets
H.PWiz
@ H.PWiz a oublié le E, désolé
Krzysztof Szewczyk le
1

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.
Urne Magique De Pieuvre
la source
Je sais qu'il ya déjà trois autres réponses de 05AB1E, donc il ne compte pas vraiment, mais vous pouvez jouer au golf 3 octets en changeant '.Kpour þet enlever le <. ( Je ne sais pas pourquoi vous même inclus le <, puisque vous déclarez votre réponse est 0-indexé Votre réponse actuelle est 1-indexé avec le. <.)
Kevin Cruijssen
Hmm .. vous pouvez également supprimer le fichier ,puisque le zip le fait implicitement, mais je vois qu'il est presque identique à la réponse de 10 octets
restante
1

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

bioweasel
la source
1

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.

isaacg
la source
1

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.

a13a22
la source
Bienvenue sur le site!
DJMcMayhem
Merci, je navigue sur Code Golf depuis un certain temps et j'ai finalement décidé de tenter ma chance moi-même.
a13a22
Cela pose quelques problèmes, principalement le fait qu’il ne semble pas y avoir d’entrée. Vous devez modifier votre fonction afin que, étant donné le nombre entier n, il produise le nthchiffre de la séquence de camembert. Vous pouvez également réduire votre nombre de tiers en réduisant vos noms de variable à un seul caractère
Taylor Scott
Désolé, j'ai corrigé les noms de variables pour le nombre d'octets. En ce qui concerne le nième chiffre, dois-je simplement définir n =? Ou prendre une entrée utilisateur?
a13a22
On dirait que vous l'avez déjà compris, mais vous devriez demander à l'utilisateur de le saisir. Cependant, il n'est pas nécessaire de mettre en forme la pièce jointe à cette invite. Vous pouvez donc l'utiliser input('')à la place deinput('n')
Taylor Scott
1

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();
        }
    }
}
TheLethalCoder
la source
Vous pouvez supprimer la parenthèse x[j++]/eà c=(x[j++]/e)*nau moins 2 octets; En outre, je pense que vous pouvez supprimer +""les deux instructions de retour et renvoyer un int au lieu de chaîne, puis ajouter -48à la deuxième instruction de retour pour convertir char en sortie int (pour -1 octet).
Kevin Cruijssen
@KevinCruijssen Les deux fonctionnent bien merci!
TheLethalCoder
1

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.

Lynn
la source
Cela casse par exemple pour n = 64, n = 65. Je ne sais pas quel est le meilleur moyen de résoudre ce problème, peut lambda n:('%02d'%ord('...'[n/2]))[n%2]- être , même s'il y a probablement mieux.
Flornquake
@ Flornquake darn, tu as raison. J'ai écrit un correctif qui est un octet plus court. Je ne peux penser à rien de mieux
Lynn
Agréable. Voici quelque chose d'encore plus court, basé sur votre idée: TIO
séisme de Florn
1

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
Dorian
la source
0

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!

Okx
la source
0

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.

TehPers
la source
1
Fonctionne très bien sur TIO avec Befunge 98: tio.run/##Hcg7DsJAEATRqzgiwtJO9/w64yxIxhkiIeD0y0JUpXc/Hu/neezq/...
pppery
0

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

Justin Mariner
la source
0

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.

Tom Carpenter
la source
0

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
RosLuP
la source
0

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
Taylor Scott
la source
La division par 10 pour décaler le point décimal (au lieu de SUBSTITUTE) peut économiser quelques octets dans la première solution.
Wernisch
0

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.

Krzysztof Szewczyk
la source