Una rebanada triangular de pi cuadrado

21

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 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
AdmBorkBork
fuente
Gracias. Además, ¿se puede redondear el último dígito? Algunas respuestas parecen hacer eso, y podría ser realmente difícil evitarlo
Luis Mendo
1
@LuisMendo Ese es un buen punto. No, no debería haber redondeo del último dígito, ya que estamos buscando los dígitos reales de pi, no una aproximación o cálculo. Lo aclararé y verificaré con los que responden.
AdmBorkBork

Respuestas:

7

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
Emigna
fuente
1
¡Felicidades por 10k!
Erik the Outgolfer
5

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)

Jonathan Allan
fuente
Esa versión "no sympy" es impresionante :)
Emigna
1
Agregué un enlace, ¡no es mi algoritmo!
Jonathan Allan
... pero si quieres "memorizar" Pi a un millón de dígitos, esto probablemente sea más fácil
Jonathan Allan
4

Mathematica, 82 bytes

Print@@Join@@Partition[RealDigits[Pi-3,10,#^2][[1]],#][[i,i-#2-1;;]]~Table~{i,#2}&
JungHwan Min
fuente
Puedes usar en #&@@lugar de [[1]].
Martin Ender
@TimmyD No. Se trunca. (n = 10, y = 10 da 1415926535979323846433832798841971937510749448164899259; el último 9es el centésimo dígito de pi, y el 101º es 8- sin redondeo)
JungHwan Min
3

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
Suever
fuente
@LuisMendo Ah! Sabía que teníamos una función para eso, pero no podía encontrarla. ¡Gracias!
Suever
@TimmyD Gracias por notarlo. Actualizado.
Suever
2

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
primo
fuente
0

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

Pete Arden
fuente
1
¡Buena respuesta! Lamentablemente, si está utilizando py no está integrado en el idioma (que estoy bastante seguro de que no lo está), deberá incluirlo en su puntuación de bytes.
AdmBorkBork
@TimmyD ¡Oh, no! Ok, déjalo conmigo !! Si simplemente pego mis números pi, eso requerirá más de 400 bytes más, así que creo que se requiere un enfoque diferente ... :)
Pete Arden