Lấy cảm hứng từ Nướng một lát Pi

Thử thách

Đưa ra đầu vào 3 <= n <= 100và 3 <= y <= n, xây dựng một n x nma trận của phần thập phân của pi( 14159...), bắt đầu ở phía trên bên trái. Sau đó, lấy hình tam giác phía trên bên phải có kích thước y x yvà ghép nó lại với nhau. Xuất số kết quả.

Ví dụ, đối với đầu vào n = 5, y = 3ma trận sau được xây dựng

14159
26535
89793
23846
26433

Sau đó, 3 x 3tam giác phía trên bên phải sẽ là

159
 35
  3

nên 159353là đầu ra.

Đầu vào

Hai số nguyên - nđại diện cho kích thước của ma trận vuông của các chữ số pi và yđại diện cho tam giác phía trên bên phải - trong bất kỳ định dạng thuận tiện .

Đầu ra

• Kết quả là số được cắt và ghép, được in / hiển thị trên màn hình, được trả về dưới dạng chuỗi, v.v.
• Trailing / khoảng trắng hàng đầu là tùy chọn, miễn là không có khoảng trắng trong đầu ra (nghĩa là, 159 35 3hoặc tương tự sẽ không hợp lệ).
• Lưu ý rằng vì chúng tôi rõ ràng đang tìm kiếm các chữ số của pi, và không phải là phép tính gần đúng hoặc tính toán, nên các câu trả lời không nên làm tròn chữ số cuối cùng của ma trận.

Quy tắc

• Đây là môn đánh gôn, vì vậy tất cả các quy tắc thông thường để chơi gôn đều áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.
• Một chương trình đầy đủ hoặc chức năng được chấp nhận.
• Sơ hở tiêu chuẩn bị cấm.

Ví dụ

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

05AB1E , 19 byte

Sử dụng mã hóa CP-1252 .

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

Hãy thử trực tuyến!

Giải trình

n=5, y=3 được sử dụng ví dụ

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 (có sympy), 100 byte

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)

Không có sympy, 260 246 244 233 231 218 byte

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

Điều này sử dụng "Thuật toán Spigot cho Pi" của Stanley Rabinowitz và Stan Wagon.

Các đối số tiêu chuẩn sẽ a,b,c,d,e,f=0,1,1,1,3,3mang lại chữ số pi đầu tiên 3, vì điều đó không bắt buộc, thuật toán được khởi tạo đến điểm trước đó 1được mang lại, giúp tiết kiệm hai byte mặc dù avà bdài hơn vì kết quả không yêu cầu cắt và icó thể bắt đầu tại 0hơn -1.

Lượt giới hạn đệ quy mặc định cho trường hợp kiểm tra cuối
Sử dụng //cho lần đầu tiên của các phép chia để str(v)có thể được thay thế bằng `v`(nếu không, nó sẽ kết thúc trong Lmột thời gian dài).
thay thế

Một phiên bản không đệ quy cho 232 byte cũng đánh giá trường hợp kiểm tra cuối cùng:

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 (thụt đầu tiên là một khoảng trắng , thụt lề thứ hai là một tab)

Toán học, 82 byte

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

MATL, 23 22 27 byte

1 byte được lưu nhờ vào @Luis

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

Dùng thử trực tuyến

Giải trình

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

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

Yêu cầu tùy chọn dòng lệnh -nMbignum=bpi, được tính là 12. Đầu vào được lấy từ stdin.

Sử dụng mẫu

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

Chỉnh sửa:

Ban đầu tôi đã sử dụng một chuỗi không đổi cho Pi bên ngoài phương thức, nhưng có vẻ như đây là gian lận. Tôi đã phải sử dụng giá trị C # Math.PI, chỉ có 14 chữ số thập phân, vì vậy mgiá trị cao nhất tôi có thể sử dụng là 3. Quay lại bảng vẽ ...

Chơi gôn

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

Ung dung:

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

Không phải là câu trả lời ngắn nhất, nhưng tôi rất vui vì tôi đã giải quyết câu hỏi này ...

Đầu ra thử nghiệm:

m   t   output
3   3   141923

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