20
\$\begingroup\$

Let's solve this user's homework; I think it's an interesting exercise!

Input

Two 3-digit natural numbers.

Outputs

Two 2-digit numbers. In each of the output numbers, one digit is taken from one input number, and the other from the other number. The choice is independent. The first output number should be the minimal possible to create using these constraints, and the second one should be the maximal such number (or vice versa).

  • Input numbers never have leading zeros; output numbers should also not have leading zeros.
  • Input and output can be encoded as numbers, strings, lists of digits, etc.

Examples (in format input - output):

123, 912 - 11, 93
888, 906 - 68, 98
100, 100 - 10, 11
222, 222 - 22, 22
123, 222 - 12, 32
798, 132 - 17, 93
Improve this question
\$\endgroup\$
5
  • 1
    \$\begingroup\$ output numbers should also not have leading zeros - but can an output be a single digit if the first digit is 0? Or can the output be just 0 if both digits are? \$\endgroup\$
    – Jitse
    Nov 10, 2020 at 12:54
  • \$\begingroup\$ Can we take input as a single 6-character string? \$\endgroup\$
    – pxeger
    Nov 10, 2020 at 16:40
  • \$\begingroup\$ Could you add 123, 222 as a test case? My first attempt solved all the current cases but failed on this one, printing 11 32 instead of 12 32. \$\endgroup\$
    – GammaFunction
    Nov 10, 2020 at 20:01
  • \$\begingroup\$ @pxeger No, I guess this is too much. You have to have some separation between the numbers. \$\endgroup\$
    – anatolyg
    Nov 10, 2020 at 21:07
  • \$\begingroup\$ Suggest testcase: 798, 132. The output should take 1 digit from each number, not two digits from same number. \$\endgroup\$
    – tsh
    Nov 11, 2020 at 2:38

34 Answers 34

Reset to default
1
2
10
\$\begingroup\$

Husk, 15 14 13 9 bytes

§,▼▲f←ṁP*

Try it online!

Takes two input arrays, outputs pair (min,max).

-1 byte from Dominic Van Essen.

-1 more byte from Dominic Van Essen (after some more struggling).

-4 bytes taking arrays of digits as input.

Explanation

§,▼▲f←ṁP*
        * cartesian product pairs of the inputs
      ṁP  map each to permuations, and flatten the list
    f←    remove elements where first digit is falsy(<10)
§,        create pair with
  ▼▲      minimum and maximum
Improve this answer
\$\endgroup\$
2
8
\$\begingroup\$

05AB1E, 11 10 bytes

â€Â9ÝKWsà‚

-1 byte thanks to @ovs.

Try it online or verify a few more test cases.

Explanation:

â           # Take the cartesian product of the digits of the two (implicit) inputs
 €Â         # Bifurcate each value within the list (short for Duplicate & Reverse copy)
   9Ý       # Push the list [0,1,2,3,4,5,6,7,8,9]
     K      # Remove those integers (so all integers with leading 0s)
      W     # Take the minimum of this list (without popping the list itself)
       s    # Swap so the list is at the top of the stack again
        à   # Pop and push its maximum
         ‚  # And pair the minimum and maximum together
            # (after which it is output implicitly as result)
Improve this answer
\$\endgroup\$
1
  • 2
    \$\begingroup\$ Dí« can be €Â. €œ would also work beacuse of the way W and à work on nested lists. \$\endgroup\$
    – ovs
    Nov 10, 2020 at 13:56
6
\$\begingroup\$

Brachylog, 15 bytes

{∋ᵐpcℕ₁₀}ᶠ⟨⌋≡⌉⟩

Try it online!

{∋ᵐpcℕ₁₀}ᶠ⟨⌋≡⌉⟩
{       }ᶠ      find all possible outputs:
 ∋ᵐ               select a digit from each number
   p              permute them
    c             merge them to a number
     ℕ₁₀          that number is >= 10
                with the list of all possible numbers:
          ⟨⌋≡⌉⟩ [minimum, maximum]

First time using ⟨⟩! :-⟩

Improve this answer
\$\endgroup\$
6
\$\begingroup\$

Jelly, 11 10 bytes

p;p@ḷ/ƇṢ.ị

Try it online!

Dyadic link. Input and output is a list of digits.

Explanation

p;p@ḷ/ƇṢ.ị
p            Cartesian product
 ;           Join with
   @         Reverse arguments
  p            Cartesian product
      Ƈ      Filter by
     /         Reduce by
    ḷ            First argument
       Ṣ     Sort
        .ị   First and last element

-1 byte by using the .ị technique to get the first and last element, thanks to caird

Improve this answer
\$\endgroup\$
2
  • 2
    \$\begingroup\$ It’s helping you out golf me even more but 10 bytes \$\endgroup\$
    – caird coinheringaahin g ♦
    Nov 10, 2020 at 14:20
  • 3
    \$\begingroup\$ @cairdcoinheringaahing I just thought of exactly the same thing by looking at your answer! :D We can take this as a team effort. \$\endgroup\$
    – xigoi
    Nov 10, 2020 at 14:31
5
\$\begingroup\$

Python 3, 81 bytes

lambda a,b:[m(k for i in a for j in b for k in(i+j,j+i)if'1'<k)for m in(min,max)]

Try it online!

Improve this answer
\$\endgroup\$
5
\$\begingroup\$

Haskell, 62 bytes

a!b=(`foldl1`[s|i<-a,j<-b,s<-[[i,j],[j,i]],s>"1"])<$>[min,max]

Try it online!

This is the same approach as Jitse's Python answer.

Improve this answer
\$\endgroup\$
5
\$\begingroup\$

C (gcc), 233 \$\cdots\$ 189 185

Saved 4 bytes thanks to gastropner!!!
Saved 9 13 bytes thanks to ceilingcat!!!

#define d(a,i)for(qsort(a,i=3,1,L"\xf06be0f\xd02917beǃ");a[--i]<49;);
s;j;i;f(a,b)char*a,*b;{d(a,i)d(b,j)s=a[2];i=a[i]<b[j]?s=b[2],a[i]:b[j];j=*a;*b++=j>*b?j=*b,*a:*b;*a++=i;*a=s;*b=j;}

Try it online!

Inputs two \$3\$-digit strings and returns the min and the max as \$2\$-digit substrings in the first \$2\$ digits of the first and second input string respectively.

Improve this answer
\$\endgroup\$
6
  • 2
    \$\begingroup\$ The number of pointers in this program make me worried \$\endgroup\$
    – Razetime
    Nov 10, 2020 at 17:34
  • 1
    \$\begingroup\$ @Razetime Why? That's how you deal with strings (and arrays) in C. \$\endgroup\$
    – Noodle9
    Nov 10, 2020 at 17:43
  • \$\begingroup\$ 208 bytes \$\endgroup\$
    – gastropner
    Nov 10, 2020 at 23:36
  • \$\begingroup\$ @gastropner Very nice - thanks! :D \$\endgroup\$
    – Noodle9
    Nov 10, 2020 at 23:59
  • \$\begingroup\$ @ceilingcat Crashes with L"\xf06be0f\xd02917beǃ" but s=*b-*a; works brilliantly - thanks! :D \$\endgroup\$
    – Noodle9
    Nov 11, 2020 at 22:00
4
\$\begingroup\$

Retina, 38 bytes

Lw$`(.).*,.*(.)
$1$2¶$2$1
A`0.
O`
,,G`

Try it online! Link includes test cases. Explanation:

Lw$`(.).*,.*(.)
$1$2¶$2$1

Take the cartesian product of the inputs and their reverses.

A`0.

Remove entries with leading zeros.

O`

Sort.

,,G`

Take the first and last result.

Improve this answer
\$\endgroup\$
4
\$\begingroup\$

Jelly, 12 11 bytes

p;U$Ḍ>Ƈ9Ṣ.ị

Try it online!

Input as a list of digits (which the Footer does for you)

-1 byte thanks to Unrelated String

How it works

p;U$Ḍ>Ƈ9Ṣ.ị - Main link. Takes x on the left and y on the right
p           - Cartesian product of the digits. Call this list X
   $        - Group the previous two commands into a monad f(X):
  U         -   Reverse each pair in X
 ;          -   And append it to X
    Ḍ       - Convert each pair back to an integer
      Ƈ     - Keep those which:
     >      -   Are greater than:
       9    -   9
        Ṣ   - Sort
         .ị - Take the first and last elements
Improve this answer
\$\endgroup\$
4
4
\$\begingroup\$

Python 2, 70 bytes

lambda*l:[m(m(set(l[i])-{'0'})+m(l[~i])for i in(0,1))for m in min,max]

Try it online!

Python 3, 70 bytes

lambda a,b:[m(m({*a}-{'0'})+m(b),m({*b}-{'0'})+m(a))for m in(min,max)]

Try it online!

These could be shorter if we can take a list of digits as numbers.

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ These could be shorter if we can take a list of digits as numbers. - Input and output can be encoded as numbers, strings, lists of digits, etc. \$\endgroup\$
    – Jitse
    Nov 11, 2020 at 8:30
4
\$\begingroup\$

JavaScript (ES6), 80 bytes

Expects a pair of 3-digit strings. Returns a pair of 2-digit integers.

a=>[(g=n=>(a+[,a]).match(~~(n/10)+'\\d*,\\d*'+n%10)?n:g(n+d%7-2))(d=10),g(d=99)]

Try it online!

How?

We use a+[,a] to concatenate a[] with itself, with a comma in between. For instance, ['123', '912'] is turned into '123,912,123,912'. (We only need the first 3 entries, but the 4th one is harmless.)

We use the recursive function g to look for some 2-digit integer n such that the above string matches ~~(n/10)+'\\d*,\\d*'+n%10. That is to say:

  • \$\lfloor n/10\rfloor\$ (the 'left' digit of \$n\$)
  • followed by some optional digits
  • followed by a comma
  • followed by some other optional digits
  • followed by \$n\bmod 10\$ (the 'right' digit of \$n\$)

We add \$(d\bmod 7)-2\$ to \$n\$ between each recursive call, where \$d\$ is also the starting point:

  • \$d=10\rightarrow (d\bmod7)-2=1\$, so we go from \$n=10\$ to \$n=99\$ (looking for the lowest valid integer)
  • \$d=99\rightarrow (d\bmod7)-2=-1\$, so we go from \$n=99\$ to \$n=10\$ (looking for the highest valid integer)
Improve this answer
\$\endgroup\$
4
\$\begingroup\$

Desmos, 9+68+147+30+49+64+27+27+8+8+51=488 9+68+93+30+49+28+9+9+8+8+33+31+27=402 bytes

Before you even go on I just want to say that I tried my hardest to golf this, but in the middle of doing this I already knew this was far from a competing answer. But by that time though, I was too far in, so I decided to continue. Upvote for effort? Or not.

Expression 1: 9 bytes

g=[0,1,2]

Expression 2: 68 bytes

f(n)=\operatorname{floor}(\frac{\operatorname{mod}(n,10^g10)}{10^g})

Expression 3: 147 93 bytes

h(a,b)=\left\{s[1]p[1]=0:j(\min(s[k(s)+1],p[k(p)+1]),q(s)+q(p)),d(j(\min(s),\min(p)))\right\}

Expression 4: 30 bytes

q(a)=\left\{k(a)=0:a,0\right\}

Expression 5: 49 bytes

k(a)=\operatorname{total}(\left\{a=0:1,0\right\})

Expression 6: 64 28 bytes

l(a,b)=d(j(\max(s),\max(p)))

Expression 7: 27 9 bytes

s=d(f(a))

Expression 8: 27 9 bytes

p=d(f(b))

Expression 9: 8 bytes

w=h(a,b)

Expression 10: 8 bytes

z=l(a,b)

Expression 11: 51 33 bytes

m(a,b)=j(10w[1]+w[2],10z[2]+z[1])

Expression 12: 31 bytes

j(a,b)=\operatorname{join}(a,b)

Expression 13: 27 bytes

d(a)=\operatorname{sort}(a)

Try It On Desmos

The function \$m(a,b)\$ is the function where you need to input the two numbers in.

Prettified version: Try It On Desmos!

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

CJam, 19 bytes

q~m*_Wf%+:iA,-$(\W=

Try it online!

Takes input as two strings and outputs two integers.

q~                    e# Push inputs                      "888" "906"
  m*                  e# Cartesian product                ["89" "80" "86" "89" "80" "86" "89" "80" "86"]
    _Wf%              e# Make a reversed copy             ["89" "80" "86" "89" "80" "86" "89" "80" "86"] ["98" "08" "68" "98" "08" "68" "98" "08" "68"]
        +:i           e# Join and parse to integers       [89 80 86 89 80 86 89 80 86 98 8 68 98 8 68 98 8 68]
           A,-        e# Remove the numbers from 0 to 9   [89 80 86 89 80 86 89 80 86 98 68 98 68 98 68]
              $       e# Sort                             [68 68 68 80 80 80 86 86 86 89 89 89 98 98 98]
               (\     e# Uncon from left                  68 [68 68 80 80 80 86 86 86 89 89 89 98 98 98]
                 W=   e# Get the last element             68 98
Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Charcoal, 30 bytes

Ｆ²⊞υＳ⟦⌊Ｅυ⁺⌊⁻ι0⌊§υ¬κ⌈Ｅ⟦υ⮌υ⟧⭆ι⌈λ

Try it online! Link is to verbose version of code. Explanation:

Ｆ²⊞υＳ

Input the two numbers as a pair of strings.

⟦

Separate the two outputs.

⌊Ｅυ⁺⌊⁻ι0⌊§υ¬κ

For each string, string take the minimum digit with 0 excluded and the minimum digit of the other string, then take the minimum result.

⌈Ｅ⟦υ⮌υ⟧⭆ι⌈λ

Of the pair and its reverse, take the maximum digit of each string, then take the maximum result.

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

MathGolf, 33 32 bytes

─■myG‼<≥xα─6ö6‼≥<3≥\;]─gÅ£(_╓\╙α

Input as a paired list of digits.

Sometimes this language is so frustrating to work with.. :/ It has a cartesian builtin, but it only works on single lists (creating pairs of itself). It also has a convenient ‼ builtin to apply two commands separately to the stack, but this isn't implemented (yet?) for the minimum/maximum builtins (otherwise the _╓\╙α could have been ‼╓╙α)..

Try it online.

Explanation:

─           # Flatten the list of list of digits
 ■          # Take the cartesian product of this flattened list
  m         # Map over each pair:
   y        #  And join them together to a single integer
            # (note: since we're joining integers, the `m` implicitly converts them to
            # integers as well, removing potential leading 0s)
    G       # Push 12
     ‼      # Apply the following two commands separated on the stack:
      <     #  Slice to only keep the first 12 items in the list
       ≥    #  Slice to remove the first 12 items from the list and keep the remainder
        x   # Reverse the second list
         α─ # Merge the lists together again (wrap in a pair; flatten)
6ö          # Loop 6 times, using the following 7 commands as body:
  6         #  Push 6
   ‼        #  Apply the following two commands separated on the stack:
    ≥       #   Slice to remove the first 6 items from the list and keep the remainder
     <      #   Slice to only keep the first 6 items in the list
      3≥    #  Slice to remove the first 3 items of this sextet
        \   #  Swap the top two lists on the stack so the remainder is at the top
  ;         # After the loop: discard the top of the stack (the final remainder)
   ]        # Wrap all triplets into a list
    ─       # And flatten it

We now have all possible pairs (including their reversed pairs).

g           # Filter this list of pairs by,
 Å          # using the following 2 commands as body:
  £         #  Get the length of this integer
   (        #  Decrease it by 1
            #  (so 0 for single digit numbers; 1 for intended two-digit numbers)
    _       # Duplicate this list of pairs
     ╓      # Pop and get its minimum
      \     # Swap so the duplicated list is at the top
       ╙    # Pop and get its maximum
        α   # And pair them together
            # (after which the entire stack joined together is output implicitly)
Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Scala, 78 bytes

a=>b=>{val z=for(x<-a;y<-b;c<-Seq(""+x+y,""+y+x)if"09"<c)yield c;z.min->z.max}

Try it online!

Apparently, just storing it in a variable is shorter than folding over all the permutations. Accepts two strings (curried) and returns a 2-tuple of strings.

Scala, 109 bytes

a=>b=>((-1>>>1,0)/:(for(x<-a;y<-b;c<-Seq(""+x+y,""+y+x)if"09"<c)yield c.toInt)){(t,|)=>(t._1 min|,t._2 max|)}

Try it online!

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Zsh, 90 bytes

for d (${(o)=${(s::)@}})((e&~a&&(a=e,b=d),${z=$d},f=e,e=d))
<<<${z/0/$a}${z/[^0]/$b}\ $d$f

Try it online!

${(o)=${(s::)@}} sorts the digits, which we loop over. By the end of the loop, we have the following parameters set:

  • z: The smallest digit
  • a: The smallest non-zero digit
  • b: The second-smallest non-zero digit
  • d,e: The largest digit
  • f: The second-largest digit.

If z is zero, then the first number is $a$z. If z is non-zero, then the first number is $z$b.

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Perl 5, 98 94 bytes

sub{@i="@_"=~/./g;(sort grep!/^0/,map{/./;$i[$&].$i[$'],$i[$'].$i[$&]}<{0,1,2}{4,5,6}>)[0,-1]}

Try it online!

Improve this answer
\$\endgroup\$
2
  • 1
    \$\begingroup\$ glob"{0,1,2}{4,5,6}" can be changed to <{0,1,2}{4,5,6}> \$\endgroup\$
    – Nahuel Fouilleul
    Nov 10, 2020 at 21:44
  • \$\begingroup\$ @NahuelFouilleul – Thanks! Saved four bytes with that tip. \$\endgroup\$
    – Kjetil S
    Nov 10, 2020 at 22:19
3
\$\begingroup\$

Japt, 13 bytes

I/O as an array of digit arrays.

rï cá fÎÍé ¯2

Try it

rï cá fÎÍé ¯2     :Implicit input of array
r                 :Reduce by
 ï                :  Cartesian product
   c              :Flat map
    á             :  Permutations
      f           :Filter by
       Î          :  First element (0 is falsey)
        Í         :Sort
         é        :Rotate right
           ¯2     :Slice to second element
Improve this answer
\$\endgroup\$
3
\$\begingroup\$

APL+WIN, 30 bytes.

Index origin = 0. Prompts for input numbers as strings:

(⌊/n~⍳10),⌈/n←,⍎¨(⌽¨n),n←⎕∘.,⎕

Try it online! Thanks to Dyalog Classic

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ I think you need ⍳10 instead of ⍳9 to filter out all single digit numbers. \$\endgroup\$
    – Bubbler
    Nov 11, 2020 at 0:08
  • \$\begingroup\$ @Bubbler Thanks, Corrected. Missed the edit when switching `index origin to filter zeros \$\endgroup\$
    – Graham
    Nov 11, 2020 at 7:28
3
\$\begingroup\$

Ruby, 77 74 70 53 bytes

-17 bytes thanks to Dingus!!

->x,y{((x-[0]).product(y)+(y-[0]).product(x)).minmax}

Try it online!

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Haskell, 62 bytes

q l=[minimum,maximum]<*>[filter(>"1")$mapM id=<<[l,reverse l]]

Try it online!

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

Wolfram Language (Mathematica), 77 bytes

MinMax@Select[FromDigits/@Join@@Permutations/@Tuples[IntegerDigits/@#],#>9&]&

Try it online!

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

Japt, 17 bytes

ïV cVïU)Íf¨A é v2

Try it

ïV             - pair each digits
   Í           - sort
    f¨A        - remove if <10
        é      - rotate array
          v2   - return first 2 elements ( Max , Min )
  • Thanks to @Shaggy for spotting an error, fixed by adding cVïU
Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ @Shaggy thanks, I didn't pay attention \$\endgroup\$
    – AZTECCO
    Nov 10, 2020 at 19:55
  • \$\begingroup\$ I had this for 13, with I/O as an array of digit arrays. Was about to post when I spotted yours. \$\endgroup\$
    – Shaggy
    Nov 10, 2020 at 19:57
  • \$\begingroup\$ I like the use of permutations and fg ! I think it's a slightly different approach.. You may post your answer and get my vote bud \$\endgroup\$
    – AZTECCO
    Nov 10, 2020 at 21:21
2
\$\begingroup\$

Perl 5 -MList::Util=min,max -p, 89 bytes

s/.\K/,/g;s/ /}{/ for($b=reverse),$_;$_=min(@a=grep$_>9,glob("{$_}"),glob"{$b}").$".max@a

Try it online!

Improve this answer
\$\endgroup\$
1
2
\$\begingroup\$

Bash, 126 153 158 bytes

for n in {10..99}; {
t=$[n/10]
o=$[n%10]
([[ $1 =~ $t && $2 =~ $o ]]||[[ $2 =~ $t && $1 =~ $o ]])&&A+=($n)
}
echo $A-${A[-1]}

Try it online!

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

JavaScript (Node.js), 76 bytes

(a,b)=>[(e=a.map(c=>b.map(d=>[c+d,d+c])).flat(3).sort()).find(x=>x>9),e[17]]

Try it online!

Input as two lists of character, output as two strings.

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

C (gcc),  147 144  141 bytes

#define g(x,d)x%q!=d&x/q%q!=d&x/100!=d
v,d=1,q=10;f(a,b){for(v=q;g(a,v/q)|g(b,v%q)&&g(b,v/q)|g(a,v%q)||printf("%d ",v)&&(v=99,d=-d)<0;v+=d);}

Try it online!

How?

The macro g(x,d) checks whether the digit d appears in the 3-digit integer x by testing \$x\bmod 10\$, \$\lfloor x/10\rfloor\bmod 10\$ and \$\lfloor x/100\rfloor\$. It returns a falsy value if successful.

We look for the first v such that \$\lfloor v/10\rfloor\$ appears in a and \$v \bmod 10\$ appears in b, or the other way around. We do it once by going from \$v=10\$ to \$v=99\$ and once by going from \$v=99\$ to \$v=10\$, to get the lowest and highest valid integers respectively.

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

R, 138 134 128(thanks pajonk) 121 117 bytes

k=t(t(expand.grid(strsplit(scan(,""),""))));class(k)=class(1);a=c(A<-k[,1],B<-k[,2]);b=c(B,A);range(10*a[a>0]+b[a>0])

Try it online!

Another solution that takes input as a list of digits, allowed per the rules:

R, 110(thanks pajonk) 103 99 93 bytes

i=scan();k=expand.grid(i[1:3],i[4:6]);a=c(A<-k[,1],B<-k[,2]);b=c(B,A);range(10*a[a>0]+b[a>0])

Try it online!

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ Second approach a little shorter: Try it online! \$\endgroup\$
    – pajonk
    Nov 12, 2020 at 11:59
  • \$\begingroup\$ @pajonk Thanks! Works for both, of course. \$\endgroup\$
    – John
    Nov 12, 2020 at 13:49
  • \$\begingroup\$ Still, the double transposition in k=... is not necessary, I think. \$\endgroup\$
    – pajonk
    Nov 13, 2020 at 11:21
  • \$\begingroup\$ @pajonk It is with the first approach (which is more general), but you're right it's not needed for the second. \$\endgroup\$
    – John
    Nov 13, 2020 at 13:38
2
\$\begingroup\$

C (MinGW), 150 146 bytes

-4 bytes thanks to ceilingcat

The TiO link needs -lm but MinGW does not.

M,m,x,y,c,t=10;f(a,b){for(M=0,m=99;a;a/=t)for(c=b;c;c/=t)M=fmax(fmax(x=a%t*t+c%t,M),y=c%t*t+a%t),m=y<m&y>9?y:m,m=x<m&x>9?x:m;printf("%d %d",m,M);}

Try it online!

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Suggest M=fmax(fmax(x=a%t*t+c%t,M),y=c%t*t+a%t) instead of x=a%t*t+c%t,y=c%t*t+a%t,M=x>M?x:M,M=y>M?y:M (may need to pass -lm to the compiler) \$\endgroup\$
    – ceilingcat
    Nov 13, 2020 at 5:02
1
2

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.