3 added 26 characters in body
source | link

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and RAMmemory.

The input will always be two positive base 10decimal integers in any reasonable format (string, list of digits..)

The output should be (exclusively, apart from any whitespace) the exact base 10decimal product of these integers.

  • If integer magnitude is unbounded in your language, you must set an own limit
  • The algorithm has to be written individually. If your language has arbitrary multiplication implemented in any way, (built-in, native support) the program has to be written in a way that assumes that these methods are limited to some number
  • Note that properties like .length are also bounded numbers, and the input can have infinitely manyexceed the integer limit. You can't e.g. ordinarily loop over the digits in a 'for' loop
  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

Sandbox

Is this different enough from this challenge?

Would this be better suited for ?

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and RAM.

The input will always be two positive base 10 integers in any reasonable format (string, list of digits)

The output should be (exclusively, apart from any whitespace) the exact base 10 product of these integers.

  • If integer magnitude is unbounded in your language, you must set an own limit
  • The algorithm has to be written individually. If your language has arbitrary multiplication implemented in any way, (built-in, native support) the program has to be written in a way that assumes that these methods are limited to some number
  • Note that properties like .length are also bounded numbers, and the input can have infinitely many digits
  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and memory.

The input will always be two positive decimal integers in any reasonable format (string, list of digits..)

The output should be (exclusively, apart from any whitespace) the exact decimal product of these integers.

  • If integer magnitude is unbounded in your language, you must set an own limit
  • The algorithm has to be written individually. If your language has arbitrary multiplication implemented in any way, (built-in, native support) the program has to be written in a way that assumes that these methods are limited to some number
  • Note that properties like .length can exceed the integer limit. You can't e.g. ordinarily loop over the digits in a 'for' loop
  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

Sandbox

Is this different enough from this challenge?

Would this be better suited for ?

2 added 206 characters in body
source | link

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and RAM.

The input will always be two positive base 10 integers in any reasonable format (string, list of digits)

The output should be (exclusively, apart from any whitespace) the exact base 10 product of these integers.

  • Some languages already natively implement thisIf integer magnitude is unbounded in your language, you must set an own limit
  • The algorithm has to be written individually. Instead write the program as if integers were limitedIf your language has arbitrary multiplication implemented in any way, (to anythingbuilt-in, native support). the program has to be written in a way that assumes that these methods are limited to some number
  • Note that properties like .length are also bounded numbers, and the input can have infinitely many digits
  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and RAM.

The input will always be two positive base 10 integers in any reasonable format (string, list of digits)

The output should be (exclusively, apart from any whitespace) the exact base 10 product of these integers.

  • Some languages already natively implement this. Instead write the program as if integers were limited (to anything).
  • Note that properties like .length are also bounded numbers, and the input can have infinitely many digits
  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and RAM.

The input will always be two positive base 10 integers in any reasonable format (string, list of digits)

The output should be (exclusively, apart from any whitespace) the exact base 10 product of these integers.

  • If integer magnitude is unbounded in your language, you must set an own limit
  • The algorithm has to be written individually. If your language has arbitrary multiplication implemented in any way, (built-in, native support) the program has to be written in a way that assumes that these methods are limited to some number
  • Note that properties like .length are also bounded numbers, and the input can have infinitely many digits
  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609

1
source | link

For technical reasons, many languages have a boundary for number values, which calls for workarounds when operating with numbers outside this range.

Challenge

The challenge is to write a program which is able to multiply two arbitrary large numbers, given an infinite amount of time and RAM.

The input will always be two positive base 10 integers in any reasonable format (string, list of digits)

The output should be (exclusively, apart from any whitespace) the exact base 10 product of these integers.

  • Some languages already natively implement this. Instead write the program as if integers were limited (to anything).
  • Note that properties like .length are also bounded numbers, and the input can have infinitely many digits
  • A valid solution can not be confirmed by solely test cases but only by analysis of the code

  • This is , so shortest code in bytes per language wins.

Example Input and Output

Input:

5378877047254281056308179853217614491205392080414948189690882584626258197090299384248418705254284062330999044417502407170242320748022675887850236280535223588025381434803683717318134517400400886554441

and

24585803251446564673599904286559945882543472174090101020256415987852946031712809185990398899511551226915139170857973433130460342507187447589801052724967977799120438910759846107262285707877865565231049

Output:

13224401279751560029079048725841743388456506005068978434329060038933262717486337348174589758627669812502604130373896959848172091197634331942663385472131265201616801014468642971825909208942693284219016467181922385520740594984640977937358293657922369959902120240111214073507556243844128492765568914803850594686913014876111459929738682018339519061223975139325785119259348090888269287247476161682038609