Inspirado en hornear una rodaja de pi

Reto

Dada la entrada 3 <= n <= 100y 3 <= y <= n, construya una n x nmatriz de la porción decimal de pi( 14159...), comenzando en la parte superior izquierda. Luego, toma el triángulo de tamaño superior derecho y x yy concatena juntos. Salida del número resultante.

Por ejemplo, para entrada n = 5, y = 3se construye la siguiente matriz

14159
26535
89793
23846
26433

Entonces, el 3 x 3triángulo superior derecho sería

159
 35
  3

Así 159353es la salida.

Entrada

Dos enteros, que nrepresentan el tamaño de la matriz cuadrada de los dígitos de pi y que yrepresentan el triángulo superior derecho, en cualquier formato conveniente .

Salida

• El número resultante dividido y concatenado, ya sea impreso / mostrado en la pantalla, devuelto como una cadena, etc.
• El espacio en blanco inicial / final es opcional, siempre que no haya espacios en blanco en la salida (es decir,159 35 3 o similares no serían válidos).
• Tenga en cuenta que dado que estamos buscando explícitamente los dígitos de pi, y no una aproximación o cálculo matemático, las respuestas no deben redondear el último dígito de la matriz.

Reglas

• Este es el código de golf, por lo que se aplican todas las reglas habituales para jugar al golf, y gana el código más corto (en bytes).
• Un programa completo o una función son aceptables.
• Las lagunas estándar están prohibidas.

Ejemplos

 n  y  output
-------------
 3  3  141923
 5  3  159353
 6  4  1592589383
 6  6  141592535893238643794
20 12  358979323846950288419715820974944628620899211706792306647223172745025559196615

05AB1E , 19 bytes

Utiliza la codificación CP-1252 .

nžs¦¦¹ôI£íRvyN>£J}R

Pruébalo en línea!

Explicación

n=5, y=3 usado por ejemplo

nžs                  # push pi to n^2 digits
                     # STACK: 3.1415926535897932384626433
   ¦¦                # remove the first 2 chars
                     # STACK: 1415926535897932384626433
     ¹ô              # split into n*n matrix
                     # STACK: ['14159', '26535', '89793', '23846', '26433']
       I£            # keep the first y rows
                     # STACK: ['14159', '26535', '89793']
         íR          # reverse the list of rows and each individual row
                     # STACK: ['39798', '53562', '95141']
           v     }   # for each y,N (row, index) in the list
            yN>£J    # keep the first index+1 digits of the row and join to string
                     # STACK: 353951
                  R  # reverse the string
                     # STACK: 159353
                     # implicit print

Python 2 (con sympy), 100 bytes

from sympy import*
lambda n,y:''.join(c for i,c in enumerate(`pi.round(n*n+1)`[2:])if i%n-i/n>n-y-1)

Sin sympy, 260 246 244 233 231 218 bytes

p=lambda n,y,a=-30,b=10,c=3,d=2,e=0,f=5,s='',i=0:i<n*n and p(n,y,*[((2*b+a)*f,b*d,c*f,d+1,(b*(7*d)+2+(a*f))/(c*f),f+2,s,i),(10*(a-e*c),10*b,c,d,((10*(3*b+a))/c)-10*e,f,s+(str(e)[:i%n-i/n>n-y-1]),i+1)][4*b+a-c<e*c])or s

Esto emplea "El algoritmo de espita para Pi" de Stanley Rabinowitz y Stan Wagon.

Los argumentos estándar serían a,b,c,d,e,f=0,1,1,1,3,3producir el primer dígito de pi, 3ya que no es necesario, el algoritmo se inicializa hasta el punto anterior 1, lo que ahorra dos bytes ay bes más largo ya que el resultado no requiere segmentación y ipuede comenzar en 0más bien que-1 .

Golpea el límite de recursión predeterminado para el último caso de prueba Se
usa //para la primera de las divisiones de modo que str(v)pueda ser reemplazado por `v`(de lo contrario, terminaría Lpor mucho tiempo).
repl.it

Una versión no recursiva para 232 bytes que también evalúa el último caso de prueba:

def p(n,y):
 a,b,c,d,e,f,i,s=-30,10,3,2,0,5,0,''
 while i<n*n:
    if 4*b+a-c<e*c:s+=`e`[:i%n-i/n>n-y-1];g=10*(a-e*c);e=((10*(3*b+a))//c)-10*e;b*=10;i+=1
    else:g=(2*b+a)*f;h=(b*(7*d)+2+(a*f))/(c*f);b*=d;c*=f;f+=2;d+=1;e=h
    a=g
 print s

repl.it (el primer guión es un espacio, el segundo guión es una pestaña)

Mathematica, 82 bytes

Print@@Join@@Partition[RealDigits[Pi-3,10,#^2][[1]],#][[i,i-#2-1;;]]~Table~{i,#2}&

MATL, 23 22 27 bytes

1 Byte guardado gracias a @Luis

UtEYPwY$IbH+&:)GetGi-&R!g)!

Pruébalo en línea

Explicación

        % Implicitly grab input (n)
Ut      % Square n and duplicate
E       % Multiply n^2 by 2
YP      % Pi literal
w       % Flip the stack
Y$      % Compute the first 2 * (n^2) digits of pi (accounts for rounding)
IbH+&:) % Grab the first n^2 digits after the decimal
Ge      % Reshape it into an n x n matrix in row-major ordering
t       % Duplicate this matrix
Gi-     % Grab the second input (y) and compute the difference between n and y
&R!     % Get the upper diagonal part and transpose to convert to lower diagonal
g)      % Convert it to a logical array and use it to select the digits of interest
!       % Transpose the result and implicitly display

Perl, 67 bytes

s/ /bpi++$_**2/e;$%=$';$%-=print/(.{$%})$/ for/\d{$`}/g

Requiere la opción de línea de comando -nMbignum=bpi , contada como 12. La entrada se toma de stdin.

Uso de muestra

$ echo 3 3 | perl -nMbignum=bpi primo-square-pi.pl
141923

$ echo 5 3 | perl -nMbignum=bpi primo-square-pi.pl
159353

$ echo 6 4 | perl -nMbignum=bpi primo-square-pi.pl
1592589383

$ echo 6 6 | perl -nMbignum=bpi primo-square-pi.pl
141592535893238643794

$ echo 20 12 | perl -nMbignum=bpi primo-square-pi.pl
358979323846950288419715820974944628620899211706792306647223172745025559196615

C #, 232 bytes 268 bytes

Editar:

Originalmente usé una cadena constante para Pi fuera del método, pero parece que esto fue una trampa. Tuve que usar el valor C # Math.PI, que solo tiene 14 decimales, por lo que el más altom valor que puedo usar es 3. Volver al tablero de dibujo ...

Golfizado:

IEnumerable<string>f(int m,int t){var a=new string[m, m];var b=Math.PI.ToString().Replace("3.","").Substring(0,m*m).ToArray();var c=0;for(int i=0;i<m;i++){for(int j=0;j<m;j++){a[i, j]=b[c]+"";c++;}}c=0;while(t>0){for(int i=t;i>0;i--){yield return a[c,m-i];}t--;c++;}}}

Sin golf:

  class ATriangularSliceOfSquaredPi
  {
    //http://www.piday.org/million/
    //const string p = "1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831";

    public IEnumerable<string> f(int m, int t)
        {
          var a = new string[m, m];

          //var b = p.Substring(0, m * m).ToArray();
          var b = Math.PI.ToString().Replace("3.", "").Substring(0, m * m).ToArray();

          var c = 0;

          for (int i = 0; i < m; i++)
          {
            for (int j = 0; j < m; j++)
            {
              a[i, j] = b[c] + "";
              c++;
            }
          }

          c = 0;

          while (t > 0)
          {
            for (int i = t; i > 0; i--)
            {
              yield return a[c, m - i];
            }
            t--;
            c++;
          }
        }
      }

No es la respuesta más corta, pero estaba feliz de haber resuelto esta ...

Prueba de salida:

m   t   output
3   3   141923

5 3 159353
6 4 1592589383
6 6 141592535893238643794
20 12 358979323846950288419715820974944628620899211706792306647223172745025559196615