Thử thách

Tính tổng lạ của hai số tự nhiên (còn được gọi là phép cộng âm lịch):

Cho A=... a2 a1 a0và B=... b2 b1 b0hai số tự nhiên được viết trong cơ sở thập phân, tổng lạ được xác định, dựa trên hoạt động tối đa , như: A+B=... max(a2,b2) max(a1,b1) max(a0,b0)

   ...         a2         a1         a0
 + ...         b2         b1         b0
 ----------------------------------------
   ...  max(a2,b2) max(a1,b1) max(a0,b0)

Đầu vào

Hai số tự nhiên

Tất cả những điều sau đây được cho phép:

• Chuỗi không đệm (cùng chiều dài)
• Các chuỗi đệm không gian bên trái
• Các chuỗi đệm bên phải
• Mảng hai chuỗi đệm
• Mảng char không gian đệm 2D

Đầu ra

Một số tự nhiên

Thí dụ

1999+2018-->2999
17210+701-->17711
32+17-->37
308+250-->358
308+25-->328

Quy tắc

• Đầu vào và đầu ra có thể được cung cấp ở bất kỳ định dạng thuận tiện nào (chọn định dạng phù hợp nhất cho ngôn ngữ / giải pháp của bạn).
• Không cần xử lý các giá trị âm hoặc đầu vào không hợp lệ
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Nếu có thể, vui lòng bao gồm một liên kết đến một môi trường thử nghiệm trực tuyến để người khác có thể thử mã của bạn!
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn, vì vậy tất cả các quy tắc chơi gôn thông thường đều được áp dụng và mã ngắn nhất (tính bằng byte) sẽ thắng.

Python 2 , 20 byte

lambda*a:map(max,*a)

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

I / O dưới dạng 0 - được liệt kê trước các chữ số.

Thạch , 1 byte

»

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

I / O dưới dạng 0 - được liệt kê trước các chữ số.

R , 68 65 byte

function(x)apply(outer(x,10^(max(nchar(x)):1-1),`%/%`)%%10,2,max)

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

Nhập dưới dạng số nguyên, đầu ra dưới dạng danh sách các chữ số.

Nếu danh sách chữ số đệm không được cho phép, thì đơn giản là pmaxđủ.

MATL , 2 byte

X>

Chọn định dạng phù hợp nhất cho ngôn ngữ / giải pháp của bạn

Định dạng đầu vào là: mảng char 2D gồm hai hàng, mỗi hàng tương ứng với một dòng, với số ngắn hơn được đệm trái với khoảng trắng. Ví dụ

17210
  701

mà trong MATL được định nghĩa là

['17210'; '  701']

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

Giải trình

      % Implicit input: 2D char array with two rows 
X>    % Take maximum of (code points of) each column
      % Implicit display

Python 2 , 73 60 56 byte

lambda a,b:map(max,zip(a.rjust(len(b)),b.rjust(len(a))))

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

Lấy đầu vào là hai chuỗi và trả về danh sách các chữ số

Thay thế:

Lấy đầu vào là hai số nguyên; cùng một đầu ra

Python 2 , 60 59 byte

lambda*i:map(max,zip(*['%*d'%(len(`max(i)`),v)for v in i]))

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

Java 10, 78 57 byte

a->b->{for(int i=a.length;i-->0;)if(a[i]<b[i])a[i]=b[i];}

Nhập vào như hai mảng ký tự đệm không gian.

Sửa đổi mảng đầu vào đầu tiên thay vì trả về một mảng mới để lưu 21 byte (nhờ @ OlivierGrégoire ).

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

Giải trình:

a->b->{            // Method with two char-array parameters and String return-type
  for(int i=a.length;i-->0;)
                   //  Loop `i` in the range (length, 0]:
    if(a[i]<b[i])  //   If the `i`'th character in input `a` is smaller than in input `b`:
      a[i]=b[i];}  //    Change the `i`'th character in `a` to the `i`'th character of `b`

J , 14 12 byte

-2 byte nhờ Jonah

(>./@,:)&.|.

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

Đầu vào và đầu ra dưới dạng danh sách các chữ số

Japt, 9 8 7 byte

Đưa đầu vào như một mảng các mảng chữ số.

mÔÕÔËrw

Thử nó

m            :Map
 Ô           :  Reverse
  Õ          :Transpose
   Ô         :Reverse
    Ë        :Map
     r       :  Reduce by
      w      :  Maximum

Nếu lấy mảng không đệm làm đầu vào được cho phép (hiện tại nó sẽ thuộc "định dạng thuận tiện" nhưng tôi nghi ngờ đó không phải là ý định của người thách thức) thì đây có thể là 3 byte.

íwV

Thử nó

í       :Interleave the first input
  V     :With the second
 w      :Reduce each pair by maximum

Perl 6 , 37 byte

{[R~] roundrobin($_».reverse)».max}

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

Lấy đầu vào là một danh sách các danh sách các chữ số.

05AB1E , 9 6 5 byte

-3 cảm ơn Emigna
-1 nhờ Shaggy

íζ€àR

Lấy đầu vào dưới dạng danh sách các chữ số

í      # Reverse both inputs
 ζ     # Zip
  ۈ   # Keep the bigger digits
    R  # Reverse

Hãy thử trực tuyến! hoặc Thử tất cả các trường hợp thử nghiệm

Perl 6 , 15 byte

{[~] [Zmax] $_}

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

Đưa đầu vào thành một danh sách các mảng ký tự được đệm không gian, mặc dù đối với thử thách này, định dạng đầu vào lỏng lẻo làm cho nó khá nhàm chán. Ngoài ra, đây là chương trình lấy danh sách hai số nguyên thay thế:

Perl 6 , 41 byte

{+[~] [Zmax] $_>>.fmt("%{.max}d")>>.comb}

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

Nếu bạn không nhớ một số lượng lớn khoảng trắng, bạn cũng có thể xóa +phần trước.

Giải trình:

{                                       }  # Anonymous code block
             $_>>    # Map each integer to 
                 .fmt("%{.max}d") # The number padded by the max of the list spaces
                                 >>.comb   # And split each to list of characters
      [Zmax]  # Get the max of each digit at each index
              # This works because space is coerced to 0
              # Otherwise we would have to add a 0 to the formatting string
  [~]   # Join the list of digits and spaces
 +      # And coerce the string to a number to get rid of leading whitespace

Haskell , 40 byte

a#b=zipWith max(p b++a)$p a++b
p=(' '<$)

Đầu vào / đầu ra dưới dạng chuỗi, thử trực tuyến!

Giải trình

Hàm pthay thế mỗi ký tự bằng một khoảng trắng, sử dụng p b++avàp a++b do đó có cùng độ dài. Bằng cách này, chúng ta có thể sử dụng zipWithmà không mất bất kỳ yếu tố nào, sử dụng maxvới nó hoạt động vì một (khoảng trắng) có điểm mã thấp hơn bất kỳ ký tự nào ['0'..'9'].

JavaScript (ES6), 51 49 byte

NB: Câu trả lời này đã được đăng trước khi các định dạng I / O lỏng lẻo được cho phép rõ ràng. Với các mảng chữ số không có đệm, điều này có thể được thực hiện trong 33 byte , (nhưng ít thú vị hơn, IMHO).

Lấy đầu vào là hai số nguyên. Trả về một số nguyên.

f=(a,b,t=10)=>a|b&&(a%t<b%t?b:a)%t+t*f(a/t,b/t)|0

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

Đã bình luận

f = (                     // f = recursive function taking:
  a,                      //   a = first integer
  b,                      //   b = second integer
  t = 10                  //   t = 10 (which is used 6 times below)
) =>                      //
  a | b                   // bitwise OR between a and b to test whether at least one of
                          // them still has an integer part
  &&                      // if not, stop recursion; otherwise:
  (                       //
    a % t < b % t ? b : a // if a % 10 is less than b % 10: use b; otherwise: use a
  ) % t +                 // isolate the last decimal digit of the selected number
  t *                     // add 10 times the result of
  f(a / t, b / t)         // a recursive call with a / 10 and b / 10
  | 0                     // bitwise OR with 0 to isolate the integer part

Phiên bản thay thế

Định dạng I / O giống nhau.

f=(a,b)=>a|b&&[f(a/10,b/10)]+(a%10<b%10?b:a)%10|0

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

Tcl , 156 byte

proc S a\ b {join [lmap x [split [format %0[set l [expr max([string le $a],[string le $b])]]d $a] ""] y [split [format %0$l\d $b] ""] {expr max($x,$y)}] ""}

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

Không phải là rất golf, nhưng tôi đã phải thử nó. Sẽ chơi golf sau!

Mẻ, 120 byte

@set/aw=1,x=%1,y=%2,z=0
@for /l %%i in (0,1,9)do @set/a"z+=w*((v=y%%10)+(v-=x%%10)*(v>>4)),y/=10,x/=10,w*=10
@echo %z%

Lấy đầu vào là tham số dòng lệnh. Phiên bản 188 byte hoạt động trên các số nguyên có độ dài tùy ý:

@set/px=
@set/py=
@set z=
:l
@if %x:~-1% gtr %y:~-1% (set z=%x:~-1%%z%)else set z=%y:~-1%%z%
@set x=%x:~,-1%
@set y=%y:~,-1%
@if "%x%" neq "" if "%y%" neq "" goto l
@echo %x%%y%%z%

Đưa đầu vào vào STDIN.

Cành , 125 byte

Khi tôi nhìn thấy thử thách này, tôi nghĩ: "hãy để tôi sử dụng ngôn ngữ mẫu! Chắc chắn là phù hợp"

Tôi đã sai ... rất sai .... ... Nhưng thật vui!

{%macro a(a,b,s='')%}{%for k,x in a|reverse|split('')%}{%set s=max(x,(b|reverse|split('')[k]))~s%}{%endfor%}{{s}}{%endmacro%}

Điều này đòi hỏi rằng "rict_variables "được đặt thành false (giá trị mặc định).

Để sử dụng macro này, bạn có thể làm như thế này:

{% import 'file.twig' as my_macro %}

{{ my_macro.a(195,67) }}

Nên hiển thị 167.

Bạn có thể thử điều này trong https://twigfiddle.com/rg0biy
("chế độ nghiêm ngặt" được đặt thành tắt, nó được bật theo mặc định trên trang web)

Husk , 5 byte

↔¤żY↔

Thuận tiện lấy đầu vào / đầu ra làm danh sách các chữ số, thử trực tuyến hoặc xác minh tất cả!

Giải trình

↔¤żY↔  -- example inputs [1,4] [3,2]
 ¤  ↔  -- reverse the arguments of: [4,1] [2,3]
  żY   -- | zipWith (keeping elements of longer) max: [4,3]
↔      -- reverse: [3,4]

Stax , 5 byte

|>E:o

Chạy và gỡ lỗi nó

Chương trình này lấy đầu vào là một chuỗi các chuỗi.

|>  Right align inputs (filling with \0)
E   "Explode" array onto stack separately
:o  "Overlay" Keep the maximum element respective element from two arrays.

Chạy cái này

Đây là lần đầu tiên tôi thấy việc sử dụng cho hướng dẫn lớp phủ "trong tự nhiên".

SNOBOL4 (CSNOBOL4) , 153 byte

	X =INPUT
	Y =INPUT
	Y =DUPL(0,SIZE(X) - SIZE(Y)) Y
S	X LEN(1) . A REM . X	:F(O)
	Y LEN(1) . B REM . Y
	O =O GT(A,B) A	:S(S)
	O =O B	:(S)
O	OUTPUT =O
END

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

Bình thường, 5 byte

meSdC

Lấy đầu vào là mảng của hai chuỗi đệm không gian.

meSd       map greatest
    C      on the transpose of input

Hãy thử nó ở đây .

Japt , 4 byte

Đầu vào được lấy dưới dạng một mảng gồm hai mảng số 0 đệm.

y_rw

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

Ceylon, 55/99

Với các chuỗi 0 hoặc đệm không gian có cùng độ dài (trả về một ký tự lặp):

function t(String a,String b)=>zipPairs(a,b).map(max);

Với các chuỗi 0 hoặc đệm không gian (trả về Chuỗi):

String t(String a,String b)=>String(zipPairs(a,b).map(max));

Với các chuỗi có độ dài khác nhau (trả về một Chuỗi):

String u(String a,String b)=>String(zipPairs(a.padLeading(b.size),b.padLeading(a.size)).map(max));

C # (.NET Core) , 57 byte

a=>b=>a.Select((x,i)=>a[i]>b[i]?x:b[i])

-1 byte bằng cách thêm currying

Dùng thử trực tuyến

Ruby , 25 byte

->a,b{a.zip(b).map &:max}

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

Danh sách đệm trước blah blah. (Mặc dù cảm thấy hơi giống như gian lận.)

Võng mạc 0.8.2 , 39 byte

+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra. Phiên bản Retina 1 45 byte trước đó chấp nhận các chuỗi không được đệm:

P^`.+
+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4
%O`.
¶.?

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra. Giải trình:

P^`.+

Pad cả hai giá trị đến cùng một chiều dài. (Chỉ Retina 1. Có nhiều cách mô phỏng điều này trong Retina 0.8.2 nhưng chúng không được chơi gôn lắm.)

+`^(.*)(.)¶(.*)(.)
$1¶$3¶$2$4

Chuyển các giá trị.

%O`.

Sắp xếp từng cặp theo thứ tự.

¶.?

Xóa tất cả các chữ số thấp và dòng mới dư thừa.

Than , 8 byte

⭆θ⌈⟦ι§ηκ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

 θ          First input
⭆           Map over characters and join
  ⌈         Maximum of
   ⟦        List of
    ι       Current character of first input and
      η     Second input
     §      Indexed by
       κ    Current index
            Implicitly print

Phiên bản 10 byte "thêm" bất kỳ số chuỗi đệm nào:

⭆§θ⁰⌈Ｅθ§λκ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Phiên bản 14 byte trước đó chấp nhận các chuỗi không được đệm:

⭆◧θＬη⌈⟦ι§◧ηＬθκ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

  θ             First input
 ◧              Padded to
   Ｌ            Length of
    η           Second input
⭆               Map over characters and join
     ⌈          Maximum of
      ⟦         List of
       ι        Current character of first input and
          η     Second input
         ◧      Padded to
           Ｌ    Length of
            θ   First input
        §       Indexed by
             κ  Current index
                Implicitly print

Phiên bản 17 byte "thêm" bất kỳ số chuỗi nào:

≔⌈ＥθＬιη⭆η⌈Ｅθ§◧ληκ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã.

Toán học 50 byte

a = 543; b = 791;

FromDigits@MapThread[Max, IntegerDigits /@ {a, b}]

(* 793 *)