Inspiré par Bake a slice of Pi

Défi

Étant donné l'entrée 3 <= n <= 100et 3 <= y <= n, construisez une n x nmatrice de la partie décimale de pi( 14159...), en commençant en haut à gauche. Ensuite, prenez le triangle de taille supérieur droit y x yet concaténez-le ensemble. Sortez le nombre résultant.

Par exemple, pour l' entrée n = 5, y = 3la matrice suivante est construit

14159
26535
89793
23846
26433

Ensuite, le 3 x 3triangle supérieur droit serait

159
 35
  3

tout 159353comme la sortie.

Contribution

Deux entiers - nreprésentant la taille de la matrice carrée des chiffres de pi, et yreprésentant le triangle supérieur droit - dans n'importe quel format pratique .

Production

• Le numéro en tranches et concaténé résultant, soit imprimé / affiché à l'écran, retourné sous forme de chaîne, etc.
• Les espaces de fin / de début sont facultatifs, tant qu'il n'y a pas d'espaces dans la sortie (c.-à-d., 159 35 3Ou similaire ne serait pas valide).
• Notez que puisque nous recherchons explicitement les chiffres de pi, et non une approximation ou un calcul mathématique, les réponses ne doivent pas arrondir le dernier chiffre de la matrice.

Règles

• Il s'agit de code-golf, donc toutes les règles habituelles pour le golf s'appliquent et le code le plus court (en octets) l'emporte.
• Un programme ou une fonction complète sont acceptables.
• Les failles standard sont interdites.

Exemples

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

05AB1E , 19 octets

Utilise l' encodage CP-1252 .

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

Essayez-le en ligne!

Explication

n=5, y=3 utilisé par exemple

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 (avec sympy), 100 octets

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)

Pas de sympy, 260 246 244 233 231 218 octets

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

Celui-ci utilise "l'algorithme de robinet pour Pi" de Stanley Rabinowitz et Stan Wagon.

Les arguments standard seraient a,b,c,d,e,f=0,1,1,1,3,3de produire le premier chiffre de pi, 3car cela n'est pas requis, l'algorithme est initialisé au point précédent 1, ce qui économise deux octets même aet best plus long car le résultat ne nécessite pas de découpage et ipeut commencer à 0plutôt que -1.

Hits limite de récursivité par défaut pour le dernier cas de test
Utilise //pour la première des divisions afin qu'il str(v)puisse être remplacé par `v`(sinon il se terminerait Lpour longtemps).
repl.it

Une version non récursive pour 232 octets qui évalue également le dernier cas de test:

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 (le premier retrait est un espace, le deuxième retrait est un onglet)

Mathematica, 82 octets

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

MATL, 23 22 27 octets

1 octet sauvé grâce à @Luis

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

Essayez-le en ligne

Explication

        % 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 octets

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

Nécessite l'option de ligne de commande -nMbignum=bpi, comptée comme 12. L'entrée provient de stdin.

Exemple d'utilisation

$ 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 octets 268 octets

Éditer:

J'ai utilisé à l'origine une chaîne constante pour Pi en dehors de la méthode, mais il semble que ce soit de la triche. J'ai dû utiliser la valeur C # Math.PI, qui n'a que 14 décimales, donc la mvaleur la plus élevée que je peux utiliser est 3. Retour à la planche à dessin ...

Golfé:

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++;}}}

Non 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++;
          }
        }
      }

Pas la réponse la plus courte, mais j'étais simplement contente d'avoir résolu celle-ci ...

Sortie de test:

m   t   output
3   3   141923

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