Misture pi e e para fazer torta!


37

Todo mundo sabe pi da constante matemática, a relação da circunferência de um círculo e seu diâmetro.

3.14159265358979323846264338327950288419716939937510...

Você provavelmente também sabe um e a constante matemática, a base de um logaritmo natural.

2.71828182845904523536028747135266249775724709369996...

Mas ... você sabe torta ? É uma das constantes mais importantes (para mim). São os dígitos de pi e e intercalados.

32.1741185298216852385485997094352233854366206248373...

Como uma expansão decimal:

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

Essa é a sequência OEIS A001355 .

PALAVRAS-CHAVE: nonn, base, burro , fácil

É uma sequência muito burra.

Desafio

Escreva um programa / função que pega um número inteiro não negativo n e gera o enésimo dígito do pie .

Especificações

  • Aplicam- se as regras de E / S padrão .
  • As brechas padrão são proibidas .
  • Sua solução deve funcionar com pelo menos 50 dígitos de cada constante, o que significa que deve funcionar com pelo menos 100 termos da sequência ( tente não codificar: P).
  • A saída para 2 ou 3 não é um ponto decimal .
  • Sua solução pode ser indexada 0 ou 1, mas especifique qual.
  • Esse desafio não é encontrar a abordagem mais curta em todos os idiomas, mas sim encontrar a abordagem mais curta em cada idioma .
  • Seu código será pontuado em bytes , geralmente na codificação UTF-8, a menos que especificado de outra forma.
  • Funções internas que computam essa sequência são permitidas, mas é recomendável incluir uma solução que não dependa de uma interna.
  • Explicações, mesmo para idiomas "práticos", são incentivadas .

Casos de teste

Estes são 0 indexados.

Input   Output

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

Em alguns formatos melhores:

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

8
De acordo com o OEIS, a palavra-chave dumbsimplesmente significa desinteressante, sem propriedades especiais.
Okx 11/08/19

1
@Downvoter Algum motivo, talvez?
totallyhuman

27
Alguém poderia argumentar que o resultado é pei, nãopie
Zaid

1
Eu não fiz o voto para baixo, mas talvez porque você não pediu isso em 3/14;)
txtechhelp

1
Às 13:59, @txtechhelp? ;)
WallyWest

Respostas:


12

Mathematica, 50 bytes

Indexado 1

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

Você pode explicar como isso funciona?
Stevoisiak

é fácil. Leva 120 (5!) Elementos de cada um e riffle-los
J42161217

Agradável! Eu tentei bater a sua solução, evitando Riffle, mas a minha solução surge um byte curto: RealDigits[If[OddQ@#,Pi,E],10,#][[1,Ceiling[#/2]]]&
Mark S.

Isso parece não funcionar. Retorna um único dígito.
21417

@DavidC Yes! .. "gera o enésimo dígito da torta" Exatamente! por que você recusou ???
precisa saber é o seguinte

9

Haskell, 154 147 146 bytes, NENHUM CÓDIGO OU USO DE CONSTANTES DE BUILTIN

Essa solução calcula e e pi usando séries infinitas e as armazena em números inteiros de ponto fixo de precisão arbitrária (tipo interno de Haskell Integere sua Rationalextensão).

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)

Indexado a 0. Preciso para a entrada 0-99, impreciso para a entrada 100-101, fora dos limites.

Explicação:

Calcula pi usando esta série infinita . Calcula e usando a série fatorial inversa clássica . Teoricamente, essas não são as fórmulas ideais para usar, pois não são muito concisas em termos de número de bytes, mas foram as únicas que pude encontrar que convergiram com rapidez suficiente para viabilizar a verificação da precisão (outras somas exigiriam centenas de milhares se milhões de termos). Na versão golfed, e é calculado com uma precisão muito maior do que o necessário para minimizar o número de contas. Ambas as constantes são calculadas com um pouco mais de dígitos do que o necessário para evitar erros de arredondamento (que são responsáveis ​​pela cauda estranha de valores incorretos).

As constantes são calculadas como proporções inteiras de precisão arbitrária ( Rational) e multiplicadas por 10 ^ 50, para que todos os dígitos necessários permaneçam intactos quando a proporção for convertida em um número inteiro (precisão arbitrária) ( Integer). Isso também evita a questão de evitar o ponto decimal nas representações de string dos números, das quais a função extrai caracteres alternativamente.


8

Táxi , 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.

Experimente online!

Tentar calcular pi ou e programaticamente em Táxi seria um pesadelo, embora eu tenha certeza que isso pode ser feito. Portanto, é muito mais curto codificar os primeiros 100 dígitos da sequência. Parece muito barato, mas é definitivamente o menor código de táxi que atende ao desafio.

Ele codifica a sequência como seqüências de caracteres, ncapta e itera npara baixo e remove o primeiro caractere da sequência a cada vez. Quando n=0, imprima o primeiro caractere. Este é um indexado.

Sem golfe / formatado:

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

6

Python 2 , 88 bytes

-4 bytes graças à ideia básica de conversão de @EriktheOutgolfer .

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

Experimente online!

Python 2 + sympy , 92 bytes

Indexado a 0. Agradeço ao Rod por me lembrar de mudar para o from sympy import*qual eu esqueci anteriormente.

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

Experimente online!

Python 2 , 114 bytes

Sinceramente, acho que a solução mais curta é a codificação permanente, já que o Python não possui built-ins úteis.

lambda n:"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Experimente online!

Python 2 , 114 bytes

Solução equivalente por @totallyhuman .

'3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919'.__getitem__

Experimente online!


Antes da votação, não se apresse em procurar uma solução mais curta.
Mr. Xcoder


@totallyhuman Obrigado
Sr. Xcoder

8
A solução equivalente que você editou é na verdade código equivalente, não contagem de bytes equivalente. : P
totallyhuman

1
@totallyhuman Lol Eu vi o seu comentário e entendi, mas esqueci completamente de consertar, porque estava rindo do meu próprio erro. Obrigado por editar!
Mr. Xcoder

5

05AB1E , 10 bytes

žsтžtøJþsè

Explicação:

ž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

Indexado a 0.

Experimente online!


1
Demasiados 05AB1Es ...: P
O Sr. Xcoder

@ Mr.Xcoder Bem, 05AB1E é a linguagem com o pi e o
built-

@ Mr.Xcoder Existem embutidos é por isso.
Erik the Outgolfer

@totallyhuman não, não faz.
Erik the Outgolfer

@Dorian Sua versão não funciona. Você está usando a versão herdada, mas žtnão havia uma lista infinita na época, e é por isso que Okx está usando os 100 primeiros dígitos de e em seu programa. Mudá-lo para a nova versão do 05AB1E (onde pi e e são uma lista infinita) ainda não funcionaria na sua versão atual, porque o zip criaria pares e o Join uniria esses pares em vez de tudo. Ainda são possíveis 9 bytes , substituindo Jpor Sna nova versão, o que a Storna uma lista achatada de caracteres / dígitos
Kevin Cruijssen 25/09

5

Python 3 , 83 80 bytes

Indexado a 0.

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

Experimente online!

Existem alguns caracteres não imprimíveis que não podem ser vistos corretamente em um navegador.

Isso funciona criando a tupla a (32, 17, 41, 18, 52, ...)partir dos códigos ASCII dos caracteres na cadeia de caracteres codificada. A tupla é convertida na string '3217411852...', na qual selecionamos o dígito direito.


4

Poliglota, 108 bytes

n=>"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"[n]

Trabalha em:

  • C #
  • Javascript

Eu acho que este é o mais curto que você pode fazer em c #, uma vez que são 252 bytes para encontrar o N - ésimo decimal de pi .


JS polyglot :-)
Arnauld

@Arnauld Updated :)
TheLethalCoder

7
Este não é um Java Polyglot! Você não pode indexar em objetos que não são de matriz em Java.
Roman Gräf

1
Isso tecnicamente funciona, mas eu diminuí a votação porque é a) não muito competitivo eb) extremamente chato e trivial.
HyperNeutrino

4
@HyperNeutrino É C # e JavaScript quando eles são competitivos? E chato e trivial, talvez, mas você preferiria que eu fiz uma resposta de 500 bytes em c # que fosse inteligente? Não, porque conflitante com o ponto 1. Isto é tão curta quanto ele ganha ...
TheLethalCoder

4

Java 8, 420 417 413 404 380 358 (calculado) e 115 110 (codificado) bytes

Calculado ( 420 417 413 404 380 358 ):

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

Experimente aqui.
Prove que gera o resultado correto para os 100 itens necessários.

Codificado ( 115 110 bytes ):

"3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919"::charAt

Experimente online.

Indexado a 0

-9 e -5 bytes graças a @Nevay .
-24 bytes graças a @ceilingcat .

  • Sua solução deve funcionar com pelo menos 50 dígitos de cada constante, o que significa que deve funcionar com pelo menos 100 termos da sequência ( tente não codificar: P)
  • Funções internas que computam essa sequência são permitidas, mas é recomendável incluir uma solução que não dependa de uma sequência interna.

Você pediu ..;)

O Java é interno Math.PIe Math.Eé duplo, que tem uma precisão máxima de apenas 16. Portanto, teremos que calcular os dois valores usando java.math.BigIntegere / ou java.math.BigDecimal.
Como já calculei o PI antes em outro desafio , usei o mesmo código usando BigInteger. O algoritmo para o número de Euler usa BigDecimalno entanto.
O resultante pe esão, portanto: 31415...e 2.718....

Provavelmente poderia jogar golfe usando apenas BigDecimal, mas estava dando algumas respostas incorretas para o PI, então agora uso ambos BigDecimale BigInteger.

Explicação:

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

Não tenho certeza se isso irá ajudá-lo, mas meu algoritmo C # para calcular pi veio 8 bytes mais curto que sua versão Java.
TheLethalCoder

Observe, porém, para que ele funcione corretamente para essa pergunta, mude (d+=2)para ++de return p%10+1para apenas return p%10.
TheLethalCoder

@TheLethalCoder Sinta-se à vontade para responder em C # a esse desafio. :) Embora você também precise calcular o número de Euler. Minha resposta é meio para lolz qualquer maneira, já codificar a saída é mais curto de qualquer maneira ..
Kevin Cruijssen

1
You've asked for it.. ;)Ei, eu gosto mais do seu primeiro. Eu tenho muito mais respostas do que eu esperava codificado ...
totallyhuman

1
Você pode salvar 9 bytes na resposta calculada usando charAt(n+1>>1)e 5 bytes na versão codificada usando uma referência de método "..."::charAt.
Nevay

3

Semente , 6015 bytes

105 41100973201674650461227976639700390615120600528953176107701316721890649738810349651490948904154731057172335535600875054878204557287393379815378680878571406244365932330202793040308312687924242319799562985464135998860369933720376853281630432469462831217924775601393232895404104191613314969008627719099002734936685651970933027922574843126481552407811220371545812798263882325951724505132794956253992779856191832909434513683936955184871247159313261417328850445886987045814618325821125417040265540589403338721758954467831926977078444612065747526326682314711350486782090838673475876960125016098416460032667015813053483457246043486676622061645094043655351781242050448580132075920324099742699960838361839038297355120817832056960516761862493176616153258281345538652844974811030063414112136642097000574165433957710342430709643110444042577685157477268110199017600011209827070311299268347100419887111107237908884608557593677163764286026624394674781868689858494991328505977301270068505397030743037416430245399054325956185200430657008806539374392625804513081295070438243600044274289109395357299275275193717501822777898664715885427884193864182834402097958423697356485767670945673525604620701482288023981110598866625872386643941558021439168402392304238271452444124214301243311025121833097491087918320170873313832323794851508364788578530614246140801266858481189449278157296335592848066512127882306035576754122325822200069362884409931190620435627809384380203617488253034370361172908245852012086081807945576657014184275798330804532115103840313004678040210379846666674881048346897213048386522262581473085489039138251061251160730845385869281787222083186331344552658814775998639661361866503862291670619153718574270905089351133527806484519543645501497150560454761284099358123613642350160410944676702481576280832672884549762767667090615809061739499629798396737503512011645776394176807352443544839957773371384141101627375926404212619777658374366513665083032140398814384622434755543347503025479743718569310129255927244046638238401670388409731849963600790867434678993019370132638962549859363736476668247251402420832876258626149639101811361047924632565285870213656416957893835899254928237592711662454838295046528789720146967061486405916116778722736283489123195985053535189375957277052428901645131462087039117212488839670735246752589931585405440449333046667938628384693216121067951290025349082277568986632815062532963505690244579740140120806885104683071514922412748240497612209609661707922754236180441892543545377867355182682381812487973645406703590150722720330526173957597156314579144484166520730013480681064941752984345205140917291104888971742824066713606933406657345121342075268990055328274845008936364502884461548416337689565392911129757761902576946104722487260155373897552821908338346641549478063474748830482136404008215583192489320750526753663943267086203954602839906762640389978523894333743126288529975769945319614142422443068420170103245659109689433597701350198280212250954698442638475209618790055335813263132865176791663235801963797561493995544185124734214257034901773781134331460320221759556924556747571745834582344275416625351302153332814233497096345055392255809024712740720006219615340819493781244665414077298346378966540544979367367978334759985048507214749726072645238624803791884339024844989975370042133733339339038567691571361407296615851372112592532463329778465699812822089846474961581380707849259093905314170108054540333209088059730272087864344697983074458088984533095183089310714804468718319244214535941276969904638763288063417624586766891798378622613765728303031397998644194508610598078718347204813844240434145846888722334194516524032354042557957058092854659539699310565707914118281251563405735083553254856313838760124953245573676126601070861004186509621892263623745673900572829301771299438501543213489182375655869072568437776298051260531944785904157204006430131566234389896821642210616326951771496269255716808352415001187083781128619236455170025989777631182990311607133740812107138446626302353752098982590371714623080450836912706275397973009559314275978915463843159370230629290376520494894845680706499809017211545204670148071902560908658269183779180493590025891585269507219866461550160579656755846447951259951641828495549544791046179035585611272240116822105364823082512055639047431280117805724371019657801828634946412396263504315569042536942671358095826696817513115447079645898107923447321583282886740680340887700198072304400536529418546232473450984945589794448490331085275232352881571706521961358975744067916422124670374397682877259664913100427726059898474024964867713698696116581478101206003313106174761699804016604950094008714907179862448792216891309734208815522069346791369498202430302292199779590583788518283934542807403049256936179914953814019565550264909025345322516061595136601312434888871667940394250767164496543418483237896796108764367721411969986710930448108645039275082356457263454340220118278471652962484104099512207532103709146426640958406853240342441810465024550617909657901698718289260589269758398513490424434162831332785821428006396653475356712733072469052427934231406388810607688824035522285626563562286337967271308076321307276537761026788485320280603487776428017017298356181654076403306265118978333909378403193559129146468182910851996415072056976175613473847242292911071040966109905552914332596680497156169349277079292398091020434667210493868422848588893205157133171899819212153010393580099455957808703428739456223073813663954919146593698106305501988107196273527346690785289909397140611634970017071011599022429384594426022933102487171920965595473754661194965266230932928905708783854897164127767575976566931916632077914904360565095752466049885656187054491320449776951484812738806536727562344348761718424255018794271994537719709226236497935053971406685810778014002594041715040546776952342303797267458880802314841325359844565479173256964507237937290466116935912176054052746039378370966040054779443633371806403649852746347690237831260027483859907620684197542069045517397230169577918374265220969534695931904

A Semente equivalente à minha resposta Befunge. Como mencionei lá, o programa Befunge que essa saída não funciona no TIO porque o TIO parece ter quebra de linha interna com 80 caracteres.


Quão? Quão?
NieDzejkob 13/08/19


3

Excel, 113 bytes

Indexado 1

=MID("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1)

PI()é preciso apenas até 15 dígitos. Semelhante para EXP(1).

Solução de 60 bytes de 60 bytes que funciona para entrada <=30 (-18 bytes graças a @Adam)

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

O conceito básico em sua segunda abordagem pode ser encurtado para 46 bytes por ter apenas o pi / e escolha dentro do if(...)comunicado: =MID(IF(ISODD(b1),PI(),EXP(1)/10)/10,b1/2+3,1).Can't contornar a imprecisão dos pi()e exp(), embora
Adam

2

05AB1E , 13 bytes

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

Experimente online!

Semelhante à resposta do Magic, mas meio diferente.

Explicação:

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


2

Japonês , 55 bytes

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

Teste online! Contém alguns não imprimíveis.

Funciona substituindo cada caractere na cadeia de caracteres por seu código e retornando o dígito no índice correto. A string foi gerada por este programa:

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

Teste online!


2

Julia, 63 bytes

Indexado 1

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

Converte pi ou e em uma seqüência de caracteres, remove a casa decimal e chama o dígito apropriado. Retorna uma representação de caractere do dígito.


1
Bem-vindo ao PPCG!
Martin Ender

2

Semente, 5852 5794

Baseado na resposta TehPers Befunge.

1051130021648715907393149878290493079600376561988348664272369051219541158034251323778110172612675089859184605166991106040693833909592598132115295033728752738087105881243462563076466678196376225832661747114302365429787133716511111381612588140144307910362782924144996564529411691568302571546828919454271683233497896594149189544327214969302848984257909609092418942847813158570493297692245428646803536815345759334224247677074872671057296478697076157019699466324478990259351466108726578472175001474585821629778406880297836753303012207209976229264609834293181367664486642493394085473509253813676093779567738697465957519812706192139261472118908699638816640825554051850436762061721281771892466822470585742923158999350909054375916612667405594051622229969696110285582900916410099224974902720736021096981441362371398922887585642863359978062601767338412679956208026294953110185271056006145171920926497396179933553547647876354874445336583594285656870801545177578902705927733720249211636847884869491097054175976937629709200212494761217184873108852140655722895359613462156833646123152648220793295854627649452190956799160703532861477096009725706141202331131287901266622861560576869037209421378739125115765163010112273561384890274706972479335859548424507413589440122160717697618157336618754196528390529316634155057447126317467878320143220148685911507025731721669456692292309133633447284353130542004299981319048073637696567634889623949341630372505055435189663767044165063763216111834588696399179737702861529836947970901482712510136315042152110633215913241916694919566433112405210063414042670097562256073600916103886503591248191758835092924394147776204171675226850914902590401360360345796925181247981647089261884952039081268986586818659090505317955579671089885915745568661758883469031230794272571159213300281445730703294269295310767401339422952480777920786878410780792687195268799097885426801795242758273587841272731685278721369746727313447085996142152811199340656395207452343492937579702451111716453371016654791322834865918860033642314402995240481293652425792697358895577606699947511030416728684352022506710677976841690749387202992493347056114389784733211172448656007595582911222364847293116425714996343958156522448560363063094260073906846664112391722958505451464414025605603413323283807093107521955579711235903403153357003170132938512689946882757999117710160645821945148763813674548797981224375547254576063310479473749044201972863935442758458424285806147218666471747061869918574545072745631758049982372007444866300485095061433951914878373501952670216546435388818497342311417254246013304856715094953051481317438104933875171470343900106719705171102058673610594748846178562080370992488881764909402902065625464750558527389775735939044400858705229893243673486621988009838791971714603625037310885148140796813757120291067372196872928228321095156712054303101901959874384063672886495472796070113365603843687513322867176197917489855537726934095360491472497352567147140246395682503059404971449739625647398820598964158265302668783916501984956044969021302601920487717382879106303683795359905325347814473318519391344565458920270463279174784746656360314070464241666622240210385245184959282222666398870656274940629675453574246097799383361429014800618720780346294542185892116417842240524776835458087900018007896901140383243611793705883547791450682392261960643824271328189332116466519255567441515615925840284456154022304291978218634565379575148642711337622789721842048696443945213454162713556316912301346193615227854869318871089808249776555077834342492281888561676171087168150941237306007109521081900169693331625918138699682645157924632842546989812618292449480799580909720292280095095845962850721356554807680991288722147671740885576811339492549454926901594927338274410385863276725958781460924134466358260089533908525106740467122470973368676988277207568882122479840074670300214980511007665457235218290742394089204192282508491125777180151491866961638111244962953268398339686189772372983926068579350047402754803068232034594024872791141428095120311259087973136353149728638143035136784730999270266072749004567217555438270988124997549762230020689881669285499865374963053282530118570884108038975805335341098720577305266629567047445192403700472887794782423940658412176424370062158626834653405675401415679083822191617061925174149189203359499283160374801737260780407460559147326758994495549579747033361234471750470244513311080274649191860724511086222353696966556035904101416366866518427071604705222938635947781869520181137451408849640159586041113639598272540062185768190959707775362176381804238896341317485410279831458927597060094913931822437950489034755418876566165098609145551163170170060968550804192429683076682433548504113044161906874992120619724109268394986529182050977866104283639955069424323124118234270471868688405770066267298550544345355480568344482162465184049105391961294335245926910436280167548428908725073049063187423431751542064521517069452498182346407984197390998799924644160478679731476796691938148057603728267749331459031937823996495889234787060791079241854542581243078812931046333013380737766914161425371301455762684652883345176576166320850926855173197613536554369628772428747263956045786416295429184651985570482338242016559363725421100270243627030197439290918962948652873397874243832067459791837014394278403085907234616003231621600132126403225123227458214686006897240158060744989458215243787817148717936756981074208678765977744940577875579654698779849605118845010395906232293740180888137656291524050590071724242335942378834532707622396324405477279768052696927856056064019532570357101573277570040254706775462396160275876038886428146097798897998315086627358220951838049046100218938610753230860169099104474379950181692561834872540511195903774693113510283120187768500261160296892119883913289017641545057765550924909632887927659777449405778755796546987798496051188450103959062322937401808881376562915240505900717242423359423788345327076223963244054772797680526969278560560640195325703571015732775700402547067754623961602758760388864281460977988979983150866273582209518380490461002189386107532308601690991044743799501816925618348725405111959037746931135102831201877685002611602968921198839132890176415450577655509249096328879276597774494057787557965469877984960511884501039590623229374018088813765629152405059007172424233594237883453270762239632440547727976805269692785605606401953257035710157327757004025470677546239616027587603888642814609779889799831508662735822095183804904610021893861075323086016909910447437995018169256183487254051119590377469311351028312018776850026116029689211988391328901764154505776555092490963288792

Bom trabalho! Estou um pouco curioso sobre como você jogou.
TehPers 23/09

2

Malbolge Unshackled (variante de rotação de 20 trit), 3,64E6 bytes

O tamanho desta resposta excede o tamanho máximo do programa postável (eh), portanto, o código está localizado no meu repositório GitHub (nota: não copie o código usando CTRL + A e CTRL + C, basta clicar com o botão direito e clicar em "Salvar elemento de destino como. .. ").

Como executar isso?

Isso pode ser uma parte complicada, porque o intérprete ingênuo de Haskell levará anos e anos para executá-lo. O TIO possui um intérprete decente do Malbogle Unshackled, mas, infelizmente, não poderei usá-lo (limitações).

O melhor que eu pude encontrar é a variante fixa de largura de rotação de 20 trit, que executa muito bem, calculando (praticamente) instantaneamente .

Para tornar o intérprete um pouco mais rápido, removi todas as verificações do interpretador 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;
}

Isso parece ter mais de 3646 bytes
H.PWiz 22/09

@ H.PWiz esqueceu o E, desculpe
Krzysztof Szewczyk

1

05AB1E , 14 bytes

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

Experimente online!


Esta resposta é indexada em 0.

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

Eu sei que já existem três outras respostas 05AB1E, por isso realmente não importa, mas você pode golfe 3 bytes, alterando '.Ka þe retire a <. (Não sei por que você ainda incluiu o <, uma vez que você indicar a sua resposta é 0-indexados Sua resposta atual é 1-indexados com o. <.)
Kevin Cruijssen

Hmm .. você também pode remover o ,desde o zip faz isso implicitamente, mas eu vejo é que quase exatamente o mesmo que a outra resposta de 10 bytes ..
Kevin Cruijssen

1

Python 3 + SymPy , 109 bytes

0-indexado Experimente online!

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

Bata a codificação por 5 bytes !! Mas provavelmente poderia ser melhor. Mas vencer a codificação me faz sentir bem :)


1

Pitão, 35 bytes

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

Suíte de teste

Como Pyth não possui constantes pi e e de precisão arbitrária integradas, eu as calculo diretamente.

Calculando pi:

u+/*GHhyHyK^T99rJ^2T0

Isto usa o seguinte recorrência continuou fração de pi computação: 2 + 1/3*(2 + 2/5*(2 + 3/7*(2 + 4/9*(2 + ...)))). Eu peguei de outra resposta PPCG . É derivado nas equações 23-25 aqui .

Eu o calculo de dentro para fora, omitindo todos os termos além do 1024, pois os termos posteriores têm pouco efeito sobre o número e mantenho 99 dígitos de precisão para garantir que os 50 primeiros estejam corretos.

Calculando e:

sm/K.!dJ

Soma os recíprocos dos primeiros 1024 números, com 99 dígitos de precisão.

Em seguida, converto ambos os números em seqüências de caracteres, os entrelaço e indexo.


1

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)

Uma explicação simples é que isso primeiro converte e e pi em strings, depois passa por um loop for concatenando os dígitos. Aqui, c é torta, p é pi e e é e.

Também dividi isso em várias linhas para facilitar a leitura, mas o código real está todo em uma linha com espaçamento mínimo.


Bem vindo ao site!
DJMcMayhem

Obrigado, eu estive navegando no Code Golf por um bom tempo e finalmente decidi tentar.
a13a22

Isso tem alguns problemas, principalmente pelo que parece não receber informações. Você precisa modificar sua função para que, dado o número inteiro n, ele produza o nthdígito da sequência Pie. Você também pode reduzir seu número de bytes, reduzindo os nomes de variáveis ​​para um único caractere
Taylor Scott

Desculpe, corrigi os nomes das variáveis ​​para a contagem de bytes. Quanto ao enésimo dígito, devo definir n =? Ou devo inserir uma entrada do usuário?
a13a22

Parece que você já percebi isso, mas você deve pedir ao utilizador para a entrada, no entanto, não é necessário ter qualquer formatação ligado a esse alerta, para que um uso input('')no lugar deinput('n')
Taylor Scott

1

C # + BigDecimal , 377 372 bytes

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

Guardado 5 bytes graças a @Kevin Cruijssen.

Nenhum link TIO por causa da biblioteca externa, infelizmente, o C # não possui uma BigDecimalclasse incorporada, portanto, essa externa precisará fazer. Provavelmente ainda é possível jogar golfe, mas não há tempo no momento.

Versão completa / formatada:

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

Você pode diminuir o parêntese x[j++]/eem c=(x[j++]/e)*n-2 bytes; Além disso, acho que você pode remover os dois +""nas duas instruções de retorno e retornar um int em vez de string e, em seguida, adicionar -48na segunda instrução de retorno para converter char em saída int (para -1 byte).
Kevin Cruijssen

@KevinCruijssen Ambos funcionam bem, obrigado!
TheLethalCoder

1

Python 2 , 82 bytes

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

Experimente online!

Contém alguns caracteres ASCII não imprimíveis. flornquake salvou dois bytes.


Isso quebra, por exemplo, para n = 64, n = 65. Não tenho certeza de qual a melhor maneira de consertar isso, talvez lambda n:('%02d'%ord('...'[n/2]))[n%2], embora provavelmente haja algo melhor.
Flornquake 15/08/19

@ Flornquake caramba, você está certo. Eu escrevi uma correção que é um byte menor. Não consigo pensar em nada melhor
Lynn

Agradável. Aqui está algo ainda mais curto, com base na sua ideia: TIO
flornquake 16/08/17

1

brainfuck , 402 bytes

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

Experimente online!

Insira como código de caractere (por exemplo, "A" = 65)

Experimente online com entrada de dígitos!

código:

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

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

0

Neim , 45 bytes

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

neim não é feito para números decimais

Experimente online!


0

Befunge , 105 bytes

3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919&0g,@

Não funciona no TIO porque parece envolver linhas internamente em 80 caracteres por algum motivo. Você pode fazê-lo funcionar no TIO colocando cada dígito em uma nova linha e tendo o&0g,@ depois o 3na primeira linha.



0

JavaScript (ES6) + mathjs , 78 bytes

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

Zero indexado e funciona até 128 números (entrada máxima de 127).

Snippet de teste

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


0

MATLAB (com caixa de ferramentas simbólica), 89 82 bytes

Ao usar a Symbolic Toolbox, esta resposta fornece uma saída sem codificar os valores de pi e e.

Como um bônus divertido, esse código como entrada pode receber um único índice ou uma matriz de índices e fornecerá simultaneamente o valor de saída para todos os valores de índice fornecidos (por exemplo, fornecer 1:10 produzirá os 10 primeiros valores).

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

(novas linhas adicionadas para facilitar a leitura, não necessárias para execução e não incluídas na contagem de bytes)

Infelizmente, a versão Octave usada pelo TIO não suporta entradas simbólicas para o vpa função, portanto, não pode fornecer no link TIO.

No MATLAB, a indexação no vetor de retorno de uma função não é possível da mesma maneira que no Octave, o que significa que este é um programa completo e não apenas uma função anônima. O programa solicitará uma entrada ndurante a execução - este é um valor indexado para o qual o elemento é necessário. No final do programa, o valor é impresso implicitamente.

Para o programa, usamos a vpafunção que fornece a 51 casas decimais o valor de pie exp(1)(e). Isso é feito simbolicamente para permitir precisão teoricamente infinita. Para expandir para mais de 100 elementos, basta aumentar o valor 51no código para aumentar o intervalo.

A quebra vpade linha char(ie char(vpa(...))) é necessária para converter a saída da função em uma cadeia de caracteres, em vez de um valor simbólico. A saída resultante é a sequência:

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

Isso inclui e e pi com 51 casas decimais - o suficiente para permitir 100 dígitos de nossa saída (precisamos fazer um pouco de dp extra do que o necessário para evitar a impressão de valores arredondados)

Para indexar essa bagunça, precisamos pelo menos nos livrar dos pontos decimais, para que ambas as seqüências de dígitos sejam contíguas. Originalmente, usei uma substituição simples de regex de qualquer coisa que não seja um dígito com nada. No entanto, eu posso salvar 7 bytes, apenas me livrando do ponto decimal usando o código:

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

string resultante é agora:

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

Ele contém todos os dígitos que precisamos com os fragmentos pi e e em índices consecutivos.

Podemos então converter o índice fornecido de forma que números ímpares acessem o fragmento pi e números pares acessem o fragmento e usando o cálculo:

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

Acessar esse índice (índices) na sequência acima fornecerá a saída correta.


0

Axioma, 148 bytes

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

Matriz baseada em 0. Resultados

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

0

Planilhas Google, 47 bytes

Nota: devido ao comprimento das constantes armazenadas no Excel e no Planilhas Google, esta solução tem precisão de apenas 20 dígitos, de acordo

Função de planilha anônima que recebe entrada da célula A1e gera esse dígito de pizza para a célula que está chamando

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

Versão codificada, 112 bytes

Esta versão atende totalmente às especificações do programa, mas geralmente não é divertida.

Função de planilha anônima que retorna o enésimo dígito na lista de torta indexada em 1

=Mid("3217411852982168523854859970943522338543662062483734873123759256062284894717957712649730999336795919",A1,1

Dividir por 10 para mudar o ponto decimal (em vez de SUBSTITUTE) pode economizar alguns bytes na primeira solução.
Wernisch

0

BFASM , 142 bytes

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

Recebe a entrada como caractere ascii, fornece a saída em forma de dígito.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.