Jeder weiß , pi die mathematische Konstante, das Verhältnis eines Kreisumfangs zu seinem Durchmesser.

3.14159265358979323846264338327950288419716939937510...

Sie wissen wahrscheinlich auch E die mathematische Konstante, die Basis eines natürlichen Logarithmus.

2.71828182845904523536028747135266249775724709369996...

Aber ... kennst du Kuchen ? Es ist eine der wichtigsten Konstanten (für mich). Es sind die Ziffern von pi und e verschachtelt.

32.1741185298216852385485997094352233854366206248373...

Als dezimale Erweiterung:

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

Dies ist die OEIS-Sequenz A001355 .

STICHWORT: nonn, Base, stumm , einfach

Es ist eine sehr dumme Sequenz.

Herausforderung

Schreiben Sie ein Programm / eine Funktion , die eine nicht negative ganze Zahl n annimmt und die n-te Stelle des Kreises ausgibt .

Spezifikationen

• Standard I / O - Regeln gelten .
• Standardlücken sind verboten .
• Ihre Lösung muss für mindestens 50 Stellen jeder Konstante funktionieren, was bedeutet, dass sie für mindestens 100 Terme der Sequenz funktionieren sollte (bitte versuchen Sie nicht, P hart zu codieren).
• Die Ausgabe für 2 oder 3 ist kein Dezimalpunkt .
• Ihre Lösung kann entweder 0-indiziert oder 1-indiziert sein. Bitte geben Sie an, welche.
• Bei dieser Herausforderung geht es nicht darum, den kürzesten Ansatz in allen Sprachen zu finden, sondern darum, den kürzesten Ansatz in jeder Sprache zu finden .
• Ihr Code wird in Bytes bewertet , normalerweise in der Codierung UTF-8, sofern nicht anders angegeben.
• Eingebaute Funktionen, die diese Sequenz berechnen, sind zulässig, es wird jedoch empfohlen, eine Lösung zu verwenden, die nicht auf einer eingebauten basiert.
• Erklärungen, auch für "praktische" Sprachen, sind erwünscht .

Testfälle

Diese sind 0-indiziert.

Input   Output

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

In ein paar besseren Formaten:

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

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

Mathematica, 50 Bytes

1-indiziert

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

Taxi , 749 Bytes

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

Probieren Sie es online!

Der Versuch, pi oder e programmatisch in Taxi zu berechnen, wäre ein Albtraum, obwohl ich mir sicher bin, dass dies möglich ist. Daher ist es viel kürzer, nur die ersten 100 Stellen in der Sequenz fest zu codieren. Es fühlt sich ziemlich billig an, aber es ist definitiv der kürzeste Taxicode, der der Herausforderung gerecht wird.

Die Sequenz wird als Zeichenfolge fest codiert, aufgenommen n, dann nach nunten durchlaufen und jedes Mal das erste Zeichen in der Zeichenfolge entfernt. Wann n=0wird das erste Zeichen ausgegeben. Dies ist einindexiert.

Nicht golfen / formatiert:

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

Haskell, 154 147 146 Byte, KEINE HARDCODIERUNG ODER VERWENDUNG VON EINGEBAUTEN KONSTANTEN

Diese Lösung berechnet e und pi mit unendlichen Reihen und speichert sie in Festkommazahlen mit willkürlicher Genauigkeit (Haskells eingebauter IntegerTyp und seine RationalErweiterung).

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-indiziert. Genau für Eingabe 0-99, ungenau für Eingabe 100-101, sonst außerhalb der Grenzen.

Erläuterung:

Berechnet pi mit dieser unendlichen Reihe . Berechnet e mit der klassischen inversen Fakultätsreihe . Theoretisch sind dies nicht die idealen Formeln, da sie in Bezug auf den Bytecount nicht sehr knapp sind, aber ich konnte feststellen, dass sie als einzige schnell genug konvergierten, um die Überprüfung der Genauigkeit durchführbar zu machen (andere Summen erforderten Hunderttausende, wenn nicht Millionen von Begriffen). In der Golfversion wird e mit einer viel höheren Genauigkeit berechnet, als zur Minimierung des Bytecount erforderlich ist. Beide Konstanten werden mit etwas mehr Stellen als erforderlich berechnet, um Rundungsfehler zu vermeiden (die für das unangenehme Ende falscher Werte verantwortlich sind).

Die Konstanten werden als ganzzahlige Verhältnisse ( Rational) mit beliebiger Genauigkeit berechnet und dann mit 10 ^ 50 multipliziert, sodass alle erforderlichen Ziffern erhalten bleiben, wenn das Verhältnis in eine ganzzahlige Zahl ( Integer) mit beliebiger Genauigkeit konvertiert wird . Dies vermeidet auch das Problem des Vermeidens des Dezimalpunkts in den Zeichenfolgendarstellungen der Zahlen, aus denen die Funktion alternativ Zeichen zeichnet.

Python 2 , 88 Bytes

-4 Bytes dank der Grundkonvertierungsidee von @EriktheOutgolfer .

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

Probieren Sie es online!

Python 2 + Sympy , 92 Bytes

0-indiziert. Vielen Dank an Rod, der mich daran erinnert hat, zu wechseln from sympy import*, was ich früher vergessen habe.

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

Probieren Sie es online!

Python 2 , 114 Bytes

Ich denke ehrlich, die kürzeste Lösung ist die Hardcodierung, da Python keine nützlichen integrierten Funktionen hat.

lambda n:"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Probieren Sie es online!

Python 2 , 114 Bytes

Äquivalente Lösung von @totallyhuman .

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919'.__getitem__

Probieren Sie es online!

05AB1E , 10 Bytes

žsтžtøJþsè

Erläuterung:

ž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-indiziert.

Probieren Sie es online!

Python 3 , 83 80 Bytes

0-indiziert.

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

Probieren Sie es online!

Es gibt einige nicht druckbare Zeichen, die in einem Browser nicht richtig angezeigt werden.

Dies funktioniert, indem das Tupel (32, 17, 41, 18, 52, ...)aus den ASCII-Codes der Zeichen im fest codierten Bytestring erstellt wird. Das Tupel wird in die Zeichenfolge konvertiert '3217411852...', aus der wir die richtige Ziffer auswählen.

Mehrsprachig, 108 Bytes

n=>"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Arbeitet in:

• C #
• JavaScript

Ich denke, dies ist die kürzeste Zeit, die Sie in C # machen können, da es 252 Bytes sind, um die N-te Dezimalstelle von pi zu finden .

Java 8, 420 417 413 404 (berechnet) & 115 110 (fest codiert) Bytes

Berechnet ( 420 417 413 404 ):

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

Hardcoded: ( 115 Bytes ):

"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"::charAt

0-indiziert

-9 und -5 Bytes dank @Nevay .

• Ihre Lösung muss für mindestens 50 Stellen jeder Konstante funktionieren, was bedeutet, dass sie für mindestens 100 Terme der Sequenz funktionieren sollte (bitte versuchen Sie nicht, P hart zu codieren).
• Eingebaute Funktionen, die diese Sequenz berechnen, sind zulässig, es wird jedoch empfohlen, eine Lösung zu verwenden, die nicht auf einer eingebauten basiert

Du hast danach gefragt ..;)

Java ist eingebaut Math.PIund Math.Ees handelt sich um Double-Werte, die eine maximale Genauigkeit von nur 16 haben. Daher müssen wir beide Werte selbst mit java.math.BigIntegerund / oder berechnen java.math.BigDecimal.
Da ich PI bereits in einer anderen Challenge berechnet habe , habe ich denselben Code mit verwendet BigInteger. Der Algorithmus für Eulers Nummer verwendet BigDecimaljedoch.
Die resultierenden pund esind daher: 31415...und 2.718....

Könnte es wahrscheinlich nur mit Golf spielen BigDecimal, gab aber einige falsche Antworten für PI, so dass ich jetzt beide BigDecimalund benutze BigInteger.

Erläuterung:

Probieren Sie es hier aus.
Beweisen Sie, dass das Ergebnis für die erforderlichen 100 Elemente korrekt ist.

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=p=BigInteger.TEN.pow(x).multiply(new BigInteger("2"));
                              //  Temp BigInteger (both `p` and `a` start at 10^25000*2)
  for(;i<x;                   //  Loop (1) 99 times (the higher the better precision)
    e=e.add(                  //    After every iteration: Add the following to `e`:
     e.ONE.divide(f,new MathContext(x,RoundingMode.HALF_UP))))
                              //     1/`f` (RoundingMode is mandatory for BigDecimal divide)
    f=f.multiply(new BigDecimal(i++));
                              //   Multiple `f` with `i`
                              //  End of loop (1) (implicit / single-line body)
  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(a))               //    After every iteration, add `a` to `p`
    a=a.multiply(new BigInteger(i+""))
                              //   Multiply `a` with `i`
       .divide(new BigInteger(2*i+++1+""));
                              //   and divide that by `2*i+1`
                              //  End of loop (2) (implicit / single-line body)
  // 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 integer to String:
        .charAt(n+1>>1);      //   `n+1` signed right shift 1 bit
}                             // End of method

Seed , 6015 Bytes

105 41100973201674650461227976639700390615120600528953176107701316721890649738810349651490948904154731057172335535600875054878204557287393379815378680878571406244365932330202793040308312687924242319799562985464135998860369933720376853281630432469462831217924775601393232895404104191613314969008627719099002734936685651970933027922574843126481552407811220371545812798263882325951724505132794956253992779856191832909434513683936955184871247159313261417328850445886987045814618325821125417040265540589403338721758954467831926977078444612065747526326682314711350486782090838673475876960125016098416460032667015813053483457246043486676622061645094043655351781242050448580132075920324099742699960838361839038297355120817832056960516761862493176616153258281345538652844974811030063414112136642097000574165433957710342430709643110444042577685157477268110199017600011209827070311299268347100419887111107237908884608557593677163764286026624394674781868689858494991328505977301270068505397030743037416430245399054325956185200430657008806539374392625804513081295070438243600044274289109395357299275275193717501822777898664715885427884193864182834402097958423697356485767670945673525604620701482288023981110598866625872386643941558021439168402392304238271452444124214301243311025121833097491087918320170873313832323794851508364788578530614246140801266858481189449278157296335592848066512127882306035576754122325822200069362884409931190620435627809384380203617488253034370361172908245852012086081807945576657014184275798330804532115103840313004678040210379846666674881048346897213048386522262581473085489039138251061251160730845385869281787222083186331344552658814775998639661361866503862291670619153718574270905089351133527806484519543645501497150560454761284099358123613642350160410944676702481576280832672884549762767667090615809061739499629798396737503512011645776394176807352443544839957773371384141101627375926404212619777658374366513665083032140398814384622434755543347503025479743718569310129255927244046638238401670388409731849963600790867434678993019370132638962549859363736476668247251402420832876258626149639101811361047924632565285870213656416957893835899254928237592711662454838295046528789720146967061486405916116778722736283489123195985053535189375957277052428901645131462087039117212488839670735246752589931585405440449333046667938628384693216121067951290025349082277568986632815062532963505690244579740140120806885104683071514922412748240497612209609661707922754236180441892543545377867355182682381812487973645406703590150722720330526173957597156314579144484166520730013480681064941752984345205140917291104888971742824066713606933406657345121342075268990055328274845008936364502884461548416337689565392911129757761902576946104722487260155373897552821908338346641549478063474748830482136404008215583192489320750526753663943267086203954602839906762640389978523894333743126288529975769945319614142422443068420170103245659109689433597701350198280212250954698442638475209618790055335813263132865176791663235801963797561493995544185124734214257034901773781134331460320221759556924556747571745834582344275416625351302153332814233497096345055392255809024712740720006219615340819493781244665414077298346378966540544979367367978334759985048507214749726072645238624803791884339024844989975370042133733339339038567691571361407296615851372112592532463329778465699812822089846474961581380707849259093905314170108054540333209088059730272087864344697983074458088984533095183089310714804468718319244214535941276969904638763288063417624586766891798378622613765728303031397998644194508610598078718347204813844240434145846888722334194516524032354042557957058092854659539699310565707914118281251563405735083553254856313838760124953245573676126601070861004186509621892263623745673900572829301771299438501543213489182375655869072568437776298051260531944785904157204006430131566234389896821642210616326951771496269255716808352415001187083781128619236455170025989777631182990311607133740812107138446626302353752098982590371714623080450836912706275397973009559314275978915463843159370230629290376520494894845680706499809017211545204670148071902560908658269183779180493590025891585269507219866461550160579656755846447951259951641828495549544791046179035585611272240116822105364823082512055639047431280117805724371019657801828634946412396263504315569042536942671358095826696817513115447079645898107923447321583282886740680340887700198072304400536529418546232473450984945589794448490331085275232352881571706521961358975744067916422124670374397682877259664913100427726059898474024964867713698696116581478101206003313106174761699804016604950094008714907179862448792216891309734208815522069346791369498202430302292199779590583788518283934542807403049256936179914953814019565550264909025345322516061595136601312434888871667940394250767164496543418483237896796108764367721411969986710930448108645039275082356457263454340220118278471652962484104099512207532103709146426640958406853240342441810465024550617909657901698718289260589269758398513490424434162831332785821428006396653475356712733072469052427934231406388810607688824035522285626563562286337967271308076321307276537761026788485320280603487776428017017298356181654076403306265118978333909378403193559129146468182910851996415072056976175613473847242292911071040966109905552914332596680497156169349277079292398091020434667210493868422848588893205157133171899819212153010393580099455957808703428739456223073813663954919146593698106305501988107196273527346690785289909397140611634970017071011599022429384594426022933102487171920965595473754661194965266230932928905708783854897164127767575976566931916632077914904360565095752466049885656187054491320449776951484812738806536727562344348761718424255018794271994537719709226236497935053971406685810778014002594041715040546776952342303797267458880802314841325359844565479173256964507237937290466116935912176054052746039378370966040054779443633371806403649852746347690237831260027483859907620684197542069045517397230169577918374265220969534695931904

Der Same entspricht meiner Befunge-Antwort. Wie ich dort erwähnte, funktioniert das Befunge-Programm, das diese Ausgaben ausgeben, nicht mit TIO, da TIO einen Zeilenumbruch von 80 Zeichen zu haben scheint.

Excel, 113 Bytes

1-indiziert

=MID("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1)

PI()ist nur bis zu 15 Stellen genau. Ähnliches gilt für EXP(1).

60 42-Byte-Lösung, die für die Eingabe funktioniert <=30 (-18 Byte dank @Adam)

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

05AB1E , 13 Bytes

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

Probieren Sie es online!

Ähnlich wie die Antwort von Magic, aber irgendwie anders.

Erläuterung:

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

Python 2 + SymPy , 70 63 Bytes

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

Probieren Sie es online!

Japt , 55 Bytes

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

Online testen! Enthält einige nicht druckbare Elemente.

Ersetzt jedes Zeichen in der Zeichenfolge durch seinen Zeichencode und gibt die Ziffer am richtigen Index zurück. Die Zeichenfolge wurde von diesem Programm generiert:

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

Online testen!

Seed, 5852 5794

Basierend auf der Antwort von TehPers Befunge.

1051130021648715907393149878290493079600376561988348664272369051219541158034251323778110172612675089859184605166991106040693833909592598132115295033728752738087105881243462563076466678196376225832661747114302365429787133716511111381612588140144307910362782924144996564529411691568302571546828919454271683233497896594149189544327214969302848984257909609092418942847813158570493297692245428646803536815345759334224247677074872671057296478697076157019699466324478990259351466108726578472175001474585821629778406880297836753303012207209976229264609834293181367664486642493394085473509253813676093779567738697465957519812706192139261472118908699638816640825554051850436762061721281771892466822470585742923158999350909054375916612667405594051622229969696110285582900916410099224974902720736021096981441362371398922887585642863359978062601767338412679956208026294953110185271056006145171920926497396179933553547647876354874445336583594285656870801545177578902705927733720249211636847884869491097054175976937629709200212494761217184873108852140655722895359613462156833646123152648220793295854627649452190956799160703532861477096009725706141202331131287901266622861560576869037209421378739125115765163010112273561384890274706972479335859548424507413589440122160717697618157336618754196528390529316634155057447126317467878320143220148685911507025731721669456692292309133633447284353130542004299981319048073637696567634889623949341630372505055435189663767044165063763216111834588696399179737702861529836947970901482712510136315042152110633215913241916694919566433112405210063414042670097562256073600916103886503591248191758835092924394147776204171675226850914902590401360360345796925181247981647089261884952039081268986586818659090505317955579671089885915745568661758883469031230794272571159213300281445730703294269295310767401339422952480777920786878410780792687195268799097885426801795242758273587841272731685278721369746727313447085996142152811199340656395207452343492937579702451111716453371016654791322834865918860033642314402995240481293652425792697358895577606699947511030416728684352022506710677976841690749387202992493347056114389784733211172448656007595582911222364847293116425714996343958156522448560363063094260073906846664112391722958505451464414025605603413323283807093107521955579711235903403153357003170132938512689946882757999117710160645821945148763813674548797981224375547254576063310479473749044201972863935442758458424285806147218666471747061869918574545072745631758049982372007444866300485095061433951914878373501952670216546435388818497342311417254246013304856715094953051481317438104933875171470343900106719705171102058673610594748846178562080370992488881764909402902065625464750558527389775735939044400858705229893243673486621988009838791971714603625037310885148140796813757120291067372196872928228321095156712054303101901959874384063672886495472796070113365603843687513322867176197917489855537726934095360491472497352567147140246395682503059404971449739625647398820598964158265302668783916501984956044969021302601920487717382879106303683795359905325347814473318519391344565458920270463279174784746656360314070464241666622240210385245184959282222666398870656274940629675453574246097799383361429014800618720780346294542185892116417842240524776835458087900018007896901140383243611793705883547791450682392261960643824271328189332116466519255567441515615925840284456154022304291978218634565379575148642711337622789721842048696443945213454162713556316912301346193615227854869318871089808249776555077834342492281888561676171087168150941237306007109521081900169693331625918138699682645157924632842546989812618292449480799580909720292280095095845962850721356554807680991288722147671740885576811339492549454926901594927338274410385863276725958781460924134466358260089533908525106740467122470973368676988277207568882122479840074670300214980511007665457235218290742394089204192282508491125777180151491866961638111244962953268398339686189772372983926068579350047402754803068232034594024872791141428095120311259087973136353149728638143035136784730999270266072749004567217555438270988124997549762230020689881669285499865374963053282530118570884108038975805335341098720577305266629567047445192403700472887794782423940658412176424370062158626834653405675401415679083822191617061925174149189203359499283160374801737260780407460559147326758994495549579747033361234471750470244513311080274649191860724511086222353696966556035904101416366866518427071604705222938635947781869520181137451408849640159586041113639598272540062185768190959707775362176381804238896341317485410279831458927597060094913931822437950489034755418876566165098609145551163170170060968550804192429683076682433548504113044161906874992120619724109268394986529182050977866104283639955069424323124118234270471868688405770066267298550544345355480568344482162465184049105391961294335245926910436280167548428908725073049063187423431751542064521517069452498182346407984197390998799924644160478679731476796691938148057603728267749331459031937823996495889234787060791079241854542581243078812931046333013380737766914161425371301455762684652883345176576166320850926855173197613536554369628772428747263956045786416295429184651985570482338242016559363725421100270243627030197439290918962948652873397874243832067459791837014394278403085907234616003231621600132126403225123227458214686006897240158060744989458215243787817148717936756981074208678765977744940577875579654698779849605118845010395906232293740180888137656291524050590071724242335942378834532707622396324405477279768052696927856056064019532570357101573277570040254706775462396160275876038886428146097798897998315086627358220951838049046100218938610753230860169099104474379950181692561834872540511195903774693113510283120187768500261160296892119883913289017641545057765550924909632887927659777449405778755796546987798496051188450103959062322937401808881376562915240505900717242423359423788345327076223963244054772797680526969278560560640195325703571015732775700402547067754623961602758760388864281460977988979983150866273582209518380490461002189386107532308601690991044743799501816925618348725405111959037746931135102831201877685002611602968921198839132890176415450577655509249096328879276597774494057787557965469877984960511884501039590623229374018088813765629152405059007172424233594237883453270762239632440547727976805269692785605606401953257035710157327757004025470677546239616027587603888642814609779889799831508662735822095183804904610021893861075323086016909910447437995018169256183487254051119590377469311351028312018776850026116029689211988391328901764154505776555092490963288792

Malbolge Unshackled (20-Trit-Rotationsvariante), 3,64E6 Bytes

Die Größe dieser Antwort überschreitet die maximal verfügbare Programmgröße (eh), sodass sich der Code in meinem GitHub-Repository befindet (Hinweis: Kopieren Sie den Code nicht mit STRG + A und STRG + C, sondern klicken Sie mit der rechten Maustaste und klicken Sie auf "Zielelement speichern unter". .. ").

Wie führe ich das aus?

Dies könnte ein schwieriger Teil sein, da naive Haskell-Interpreter eine Ewigkeit brauchen, um dies auszuführen. TIO hat einen anständigen Malbogle Unshackled-Interpreter, aber leider kann ich ihn nicht verwenden (Einschränkungen).

Das Beste, was ich finden konnte, ist die Variante mit fester Rotationsbreite von 20 Trit, die sehr gut funktioniert und (fast ) sofort berechnet .

Um den Dolmetscher ein bisschen schneller zu machen, habe ich alle Checks von Matthias Lutters Malbolge Unshackled-Dolmetscher entfernt.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

05AB1E , 14 Bytes

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

Probieren Sie es online!

Diese Antwort ist 0-indiziert.

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

Python 3 + SymPy , 109 Bytes

0-indiziert Probieren Sie es online!

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

Schlage die Hardcodierung um 5 Bytes !! Könnte aber wohl besser sein. Aber wenn ich hartcodiere, fühle ich mich gut :)

Pyth, 35 Bytes

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

Testsuite

Da in Pyth keine pi- und e-Konstanten mit willkürlicher Genauigkeit eingebaut sind, berechne ich sie direkt.

Pi berechnen:

u+/*GHhyHyK^T99rJ^2T0

Dies verwendet die folgende Wiederholung fortgesetzt Fraktion zu berechnen pi: 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + ...)))). Ich habe es von einer anderen PPCG Antwort . Es wird in Gleichungen 23-25 hier .

Ich berechne es von innen nach außen und lasse alle Terme über 1024 hinaus unberücksichtigt, da die späteren Terme nur geringe Auswirkungen auf die Zahl haben. Außerdem behalte ich eine Genauigkeit von 99 Stellen bei, um sicherzustellen, dass die ersten 50 korrekt sind.

Berechnung e:

sm/K.!dJ

Ich summiere die Kehrwerte der ersten 1024 Zahlen mit einer Genauigkeit von 99 Stellen.

Dann konvertiere ich beide Zahlen in Strings, verschachtele sie und indexiere sie.

MATLAB, 93 Bytes

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

Eine einfache Erklärung ist, dass dies zuerst e und pi in Zeichenfolgen konvertiert und dann eine for-Schleife durchläuft, die die Ziffern verkettet. Hier ist c pie, p ist pi und e ist e.

Ich habe dies zur besseren Lesbarkeit auch in mehrere Zeilen unterteilt, aber der eigentliche Code befindet sich in einer Zeile mit minimalem Abstand.

Julia, 63 Bytes

1-indiziert

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

Konvertiert pi oder e in eine Zeichenfolge, entfernt die Dezimalstelle und ruft dann die entsprechende Ziffer auf. Gibt eine Zeichendarstellung der Ziffer zurück.

C # + BigDecimal , 377 372 Bytes

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

5 Bytes dank @Kevin Cruijssen gespeichert.

Kein TIO-Link wegen der externen Bibliothek, leider hat C # keine eingebaute BigDecimalKlasse, daher muss diese externe Klasse dies tun. Möglicherweise ist Golfspielen noch möglich, aber momentan ist keine Zeit.

Voll / Formatierte Version:

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

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

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

                    long c, n, e, p = 0;

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

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

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

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

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

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

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

            Console.ReadLine();
        }
    }
}

Python 2 , 82 Bytes

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

Probieren Sie es online!

Enthält einige nicht druckbare ASCII-Zeichen. Flornquake sparte zwei Bytes.

Neim , 45 Bytes

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

neim ist nicht für Dezimalzahlen gemacht

Probieren Sie es online!

Befunge , 105 Bytes

3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919&0g,@

Funktioniert nicht mit TIO, da es aus irgendeinem Grund scheint, dass Zeilen intern mit 80 Zeichen umbrochen werden. Sie können bekommen sie , indem sie jede Ziffer in einer neuen Zeile auf TIO zu arbeiten, und die, die &0g,@nach dem 3in der ersten Zeile.

JavaScript (ES6) + mathjs , 78 Bytes

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

Null indiziert und arbeitet bis zu 128 Nummern (max Eingabe von 127).

Testschnipsel

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 (mit Symbolic Toolbox), 89 82 Bytes

Mithilfe der Symbolic Toolbox liefert diese Antwort eine Ausgabe, ohne die Werte von pi und e fest zu codieren.

Als Spaßbonus kann dieser Code als Eingabe entweder einen einzelnen Index oder ein Array von Indizes annehmen und gleichzeitig den Ausgabewert für alle angegebenen Indexwerte bereitstellen (z. B. wenn 1:10 angegeben wird, werden die ersten 10 Werte ausgegeben).

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

^{(Neue Zeilen für die Lesbarkeit hinzugefügt, für die Ausführung nicht erforderlich, daher nicht in der Byteanzahl enthalten)}

Leider unterstützt die von TIO verwendete Octave-Version keine symbolischen Eingaben für die vpaFunktion und kann daher bei TIO-Link nicht bereitgestellt werden.

In MATLAB ist die Indizierung einer Funktion in den Rückgabevektor nicht wie bei Octave möglich. Dies bedeutet, dass es sich um ein vollständiges Programm und nicht nur um eine anonyme Funktion handelt. Das Programm fordert nwährend der Ausführung zur Eingabe auf - dies ist ein indizierter Wert, für den ein Element erforderlich ist. Am Ende des Programms wird der Wert implizit gedruckt.

Für das Programm verwenden wir die vpaFunktion, die auf 51 Dezimalstellen den Wert von piund exp(1)(e) liefert . Dies geschieht symbolisch, um theoretisch eine unendliche Präzision zu ermöglichen. Erhöhen Sie zum Erweitern auf mehr als 100 Elemente einfach den Wert 51im Code, um den Bereich zu vergrößern.

Einwickeln vpain char(dh char(vpa(...))) ist notwendig , um die Ausgabe der Funktion in eine Zeichenfolge , anstatt einen symbolischen Wert zu konvertieren. Die resultierende Ausgabe ist die Zeichenfolge:

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

Dies schließt sowohl e als auch pi mit 51 Dezimalstellen ein - genug, um 100 Stellen unserer Ausgabe zuzulassen (wir müssen etwas mehr dp als erforderlich tun, um das Ausdrucken gerundeter Werte zu vermeiden).

Um dieses Durcheinander zu erkennen, müssen wir zumindest die Dezimalstellen entfernen, damit beide Ziffernfolgen zusammenhängend sind. Ursprünglich habe ich einen einfachen Regex-Ersatz für alles verwendet, was keine Ziffer mit nichts ist. Ich kann jedoch 7 Bytes einsparen, indem ich nur den Dezimalpunkt mit dem folgenden Code entferne:

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

Die resultierende Zeichenfolge lautet jetzt:

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

Dies enthält alle Ziffern, die wir für pi- und e-Chunks in aufeinanderfolgenden Indizes benötigen.

Wir können dann den bereitgestellten Index so konvertieren, dass ungerade Zahlen auf den Pi-Chunk und gerade Zahlen auf den E-Chunk zugreifen.

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

Wenn Sie auf diesen (jene) Index (Indizes) in der obigen Zeichenfolge zugreifen, erhalten Sie die richtige Ausgabe.

Axiom, 148 Bytes

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

0-basiertes Array. Ergebnisse

(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 Bytes

Hinweis: Aufgrund der Länge der in Excel und Google Sheets gespeicherten Konstanten ist diese Lösung dementsprechend nur auf 20 Stellen genau

Anonyme Arbeitsblattfunktion, die Eingaben von der Zelle entgegennimmt A1und diese Ziffer von Pie an die aufrufende Zelle ausgibt

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

Hardcoded Version, 112 Bytes

Diese Version entspricht voll und ganz der Programmspezifikation, macht aber im Allgemeinen keinen Spaß.

Anonyme Arbeitsblattfunktion, die die n-te Ziffer in der 1-indizierten Liste des Kreises zurückgibt

=Mid("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1

BFASM , 142 Bytes

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

Nimmt Eingaben als ASCII-Zeichen, gibt Ausgaben in Form von Ziffern aus.

Brainfuck , 5971 Bytes

Direkte Übersetzung meiner anderen bfasm Antwort.

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

Probieren Sie es online!