ท้าทาย

คำนวณผลรวมที่แปลกประหลาดของตัวเลขธรรมชาติสองตัว (หรือที่เรียกว่าการเติมจันทรคติ):

กำหนดA=... a2 a1 a0และB=... b2 b1 b0สองจำนวนธรรมชาติที่เขียนในฐานสิบทศนิยมผลรวมที่แปลกประหลาดถูกกำหนดขึ้นอยู่กับการดำเนินงานสูงสุดเป็น: 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)

อินพุต

ตัวเลขธรรมชาติสองตัว

อนุญาตทั้งหมดต่อไปนี้:

• สตริง zero-padded (ความยาวเท่ากัน)
• สตริงที่มีพื้นที่เบาะด้านซ้าย
• สตริงพื้นที่เบาะขวา
• อาเรย์ของสองสายเสริม
• ถ่านแบบสองมิติที่มีพื้นที่เบาะ

เอาท์พุต

ตัวเลขธรรมชาติ

ตัวอย่าง

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

กฎระเบียบ

• สามารถกำหนดอินพุตและเอาต์พุตในรูปแบบที่สะดวก (เลือกรูปแบบที่เหมาะสมที่สุดสำหรับภาษา / โซลูชันของคุณ)
• ไม่จำเป็นต้องจัดการค่าลบหรืออินพุตที่ไม่ถูกต้อง
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
• หากเป็นไปได้โปรดรวมลิงค์ไปยังสภาพแวดล้อมการทดสอบออนไลน์เพื่อให้ผู้อื่นสามารถลองใช้รหัสของคุณได้!
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

Python 2 , 20 ไบต์

lambda*a:map(max,*a)

ลองออนไลน์!

I / O เป็นรายการตัวเลขแบบหุ้มล่วงหน้า

เยลลี่ขนาด 1 ไบต์

»

ลองออนไลน์!

I / O เป็นรายการตัวเลขแบบหุ้มล่วงหน้า

R , 68 65 ไบต์

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

ลองออนไลน์!

อินพุตเป็นจำนวนเต็มเอาต์พุตเป็นรายการของตัวเลข

หากอนุญาตให้มีรายการตัวเลขหลักที่ไม่มีการเติมเต็มpmaxจะทำให้พอเพียง

MATL , 2 ไบต์

X>

เลือกรูปแบบที่เหมาะสมที่สุดสำหรับภาษา / โซลูชันของคุณ

รูปแบบอินพุตคือ: อาร์เรย์ถ่าน 2 มิติของสองแถวแต่ละแถวสอดคล้องกับบรรทัดโดยมีจำนวนที่น้อยกว่า ตัวอย่างเช่น

17210
  701

ซึ่งใน MATL หมายถึง

['17210'; '  701']

ลองออนไลน์!

คำอธิบาย

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

Python 2 , 73 60 56 ไบต์

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

ลองออนไลน์!

รับอินพุตเป็นสองสตริงและส่งคืนรายการของตัวเลข

ทางเลือก:

รับอินพุตเป็นจำนวนเต็มสองตัว เอาท์พุทเดียวกัน

Python 2 , 60 59 ไบต์

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

ลองออนไลน์!

Java 10, 78 57 ไบต์

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

ป้อนข้อมูลเป็นอะเรย์สองอักขระที่มีช่องว่าง

แก้ไขอินพุตอาร์เรย์แรกแทนที่จะส่งคืนใหม่เพื่อบันทึก 21 ไบต์ (ขอบคุณ@ OlivierGrégoire )

ลองออนไลน์

คำอธิบาย:

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 ไบต์

-2 ไบต์ขอบคุณโจนาห์

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

ลองออนไลน์!

อินพุตและเอาต์พุตเป็นรายการของตัวเลข

Japt, 9 8 7 ไบต์

รับอินพุตเป็นอาร์เรย์ของอาร์เรย์หลัก

mÔÕÔËrw

ลองมัน

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

หากใช้อาร์เรย์ที่ไม่มีเบาะรองในขณะที่อนุญาตให้ป้อนข้อมูล (ขณะนี้จะอยู่ภายใต้ "รูปแบบที่สะดวก" แต่ฉันสงสัยว่านั่นไม่ใช่เจตนาของผู้ท้าชิง) นี่อาจเป็น 3 ไบต์

íwV

ลองมัน

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

Perl 6 , 37 ไบต์

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

ลองออนไลน์!

รับอินพุตเป็นรายการของตัวเลข

05AB1E , 9 6 5 ไบต์

-3 ขอบคุณEmigna
-1 ขอบคุณShaggy

íζ€àR

รับอินพุตเป็นรายการของตัวเลข

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

ลองออนไลน์! หรือลองกรณีทดสอบทั้งหมด

Perl 6 , 15 ไบต์

{[~] [Zmax] $_}

ลองออนไลน์!

ใช้อินพุตเป็นรายการของอาร์เรย์ที่มีช่องว่างของอักขระแม้ว่าสำหรับความท้าทายนี้รูปแบบอินพุต lax ทำให้ค่อนข้างน่าเบื่อ หรือนี่คือโปรแกรมที่รับรายการจำนวนเต็มสองจำนวนแทน:

Perl 6 , 41 ไบต์

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

ลองออนไลน์!

หากคุณไม่สนใจช่องว่างขนาดใหญ่คุณสามารถลบส่วนที่+อยู่ด้านหน้าออกได้

คำอธิบาย:

{                                       }  # 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 ไบต์

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

อินพุต / เอาต์พุตเป็นสตริงลองออนไลน์!

คำอธิบาย

ฟังก์ชั่นpจะแทนที่อักขระแต่ละตัวด้วยช่องว่างใช้p b++aและp a++bทำให้มีความยาวเท่ากัน วิธีนี้เราสามารถใช้zipWithโดยไม่สูญเสียองค์ประกอบใด ๆ โดยใช้maxกับมันทำงานเพราะ(เว้นวรรค) มีจุดโค้ดต่ำกว่าใด ๆ ['0'..'9']ของตัวละคร

JavaScript (ES6), 51 49 ไบต์

หมายเหตุ: คำตอบนี้ถูกโพสต์ก่อนที่รูปแบบ I / O หลวมได้รับอนุญาตอย่างชัดเจน ด้วยอาเรย์ตัวเลขศูนย์ที่มีเบาะรองสามารถทำได้ใน33 ไบต์ (แต่น่าสนใจน้อยกว่า IMHO)

รับอินพุตเป็นจำนวนเต็มสองตัว ส่งคืนจำนวนเต็ม

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

ลองออนไลน์!

แสดงความคิดเห็น

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

รุ่นอื่น

รูปแบบ I / O เดียวกัน

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

ลองออนไลน์!

Tcl , 156 ไบต์

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)}] ""}

ลองออนไลน์!

ไม่ค่อยเล่นกอล์ฟ แต่ฉันต้องลองดู จะตีกอล์ฟทีหลัง!

แบตช์ 120 ไบต์

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

รับอินพุตเป็นพารามิเตอร์บรรทัดคำสั่ง รุ่น 188 ไบต์ใช้งานได้กับจำนวนเต็มแบบยาว:

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

ใช้อินพุตบน STDIN

Twig , 125 ไบต์

เมื่อฉันเห็นความท้าทายนี้ฉัน: "ให้ฉันใช้ภาษาเทมเพลต!

ฉันผิด ... ผิดมาก .... ... แต่สนุก!

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

สิ่งนี้ต้องการว่า "เข้มงวด_variables" ถูกตั้งค่าเป็นfalse(ค่าเริ่มต้น)

หากต้องการใช้มาโครนี้คุณสามารถทำสิ่งนี้ได้:

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

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

ควรแสดง 167

คุณสามารถลองทำสิ่งนี้ได้ในhttps://twigfiddle.com/rg0biy
("เข้มงวด_variables" ตั้งเป็นปิดโดยค่าเริ่มต้นจะเปิดใช้งานบนเว็บไซต์)

Husk , 5 ไบต์

↔¤żY↔

รับอินพุต / เอาต์พุตเป็นรายการหลักอย่างสะดวกสบายลองออนไลน์หรือยืนยันเลย!

คำอธิบาย

↔¤ż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 ไบต์

|>E:o

เรียกใช้และแก้ไขข้อบกพร่อง

โปรแกรมนี้รับอินพุตเป็นอาร์เรย์ของสตริง

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

เรียกใช้อันนี้

นี่เป็นครั้งแรกที่ฉันได้เห็นการใช้คำแนะนำการซ้อนทับ "ในป่า"

SNOBOL4 (CSNOBOL4) , 153 ไบต์

	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

ลองออนไลน์!

Pyth, 5 ไบต์

meSdC

รับอินพุตเป็นอาร์เรย์ของสองสตริงที่มีช่องว่าง

meSd       map greatest
    C      on the transpose of input

ลองมันนี่

Japt , 4 ไบต์

อินพุตถูกใช้เป็นอาร์เรย์ของอาร์เรย์หมายเลข 0-padded สองตัว

y_rw

ลองออนไลน์!

Ceylon, 55/99

ด้วยสตริง 0- หรือช่องว่างที่มีความยาวเท่ากัน (ส่งคืนอักขระที่ซ้ำได้):

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

ด้วยสตริง 0- หรือ space-padded (ส่งคืนสตริง):

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

ด้วยสตริงที่มีความยาวต่างกัน (ส่งคืนสตริง):

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

C # (. NET Core) , 57 ไบต์

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

-1 ไบต์โดยเพิ่มการแกง

ลองใช้ออนไลน์

Ruby , 25 ไบต์

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

ลองออนไลน์!

รายชื่อบุนวมก่อน blah blah (ถึงแม้ว่ามันจะรู้สึกโกงเหมือนกัน)

เรติน่า 0.8.2 , 39 ไบต์

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

ลองออนไลน์! การเชื่อมโยงรวมถึงชุดทดสอบ Retina 1 ไบต์ขนาด 45 ไบต์ก่อนหน้ายอมรับสตริงที่ไม่มีการเติม:

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

ลองออนไลน์! การเชื่อมโยงรวมถึงชุดทดสอบ คำอธิบาย:

P^`.+

แพดค่าทั้งสองให้มีความยาวเท่ากัน (Retina 1 เท่านั้นมีหลายวิธีในการลอกเลียนแบบใน Retina 0.8.2 แต่พวกมันไม่ได้กอล์ฟมาก)

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

แปลงค่า

%O`.

เรียงแต่ละคู่ตามลำดับ

¶.?

ลบตัวเลขที่ต่ำทั้งหมดและการขึ้นบรรทัดใหม่ที่มากเกินไป

ถ่าน 8 ไบต์

⭆θ⌈⟦ι§ηκ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

 θ          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

รุ่น 10 ไบต์ "เพิ่ม" จำนวนของสตริงที่มีเบาะใด ๆ :

⭆§θ⁰⌈Ｅθ§λκ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด เวอร์ชัน 14 ไบต์ก่อนหน้ายอมรับสตริงที่ไม่มีการเติม:

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

  θ             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

รุ่น 17 ไบต์ "เพิ่ม" สตริงจำนวนเท่าใดก็ได้:

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด

Mathematica 50 ไบต์

a = 543; b = 791;

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

(* 793 *)