Replace array element with multiplication of neighbors in Scala
Given an array of integers, update the index with multiplication of previous and next integers,
Input: 2 , 3, 4, 5, 6
Output: 2*3, 2*4, 3*5, 4*6, 5*6
Following is a scala implementation for the same. Kindly review.
import scala.util.Random
object NeighborMultiplication extends App {
val numbers = List.fill(10)(Random.nextInt(10))
println(numbers mkString ",")
def multiplication(l: List[Int], carryOver: Int = 1, useCarryOver: Boolean = false ): List[Int] = l match {
case Nil => List()
case x::Nil => List(carryOver * x)
case x::y::Nil => List(carryOver * x * y, y * x)
case x::y::z::Nil => List(carryOver * x * y, x * z, y * z)
case x::y::z::tail =>
if (useCarryOver) List(carryOver * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
else List(x * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
}
println(multiplication(numbers).mkString(","))
}
array recursion interview-questions functional-programming scala
asked Dec 27 '18 at 23:18
vikrant
787
add a comment |
Given an array of integers, update the index with multiplication of previous and next integers,
Input: 2 , 3, 4, 5, 6
Output: 2*3, 2*4, 3*5, 4*6, 5*6
Following is a scala implementation for the same. Kindly review.
import scala.util.Random
object NeighborMultiplication extends App {
val numbers = List.fill(10)(Random.nextInt(10))
println(numbers mkString ",")
def multiplication(l: List[Int], carryOver: Int = 1, useCarryOver: Boolean = false ): List[Int] = l match {
case Nil => List()
case x::Nil => List(carryOver * x)
case x::y::Nil => List(carryOver * x * y, y * x)
case x::y::z::Nil => List(carryOver * x * y, x * z, y * z)
case x::y::z::tail =>
if (useCarryOver) List(carryOver * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
else List(x * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
}
println(multiplication(numbers).mkString(","))
}
array recursion interview-questions functional-programming scala
asked Dec 27 '18 at 23:18
vikrant
787
add a comment |
Given an array of integers, update the index with multiplication of previous and next integers,
Input: 2 , 3, 4, 5, 6
Output: 2*3, 2*4, 3*5, 4*6, 5*6
Following is a scala implementation for the same. Kindly review.
import scala.util.Random
object NeighborMultiplication extends App {
val numbers = List.fill(10)(Random.nextInt(10))
println(numbers mkString ",")
def multiplication(l: List[Int], carryOver: Int = 1, useCarryOver: Boolean = false ): List[Int] = l match {
case Nil => List()
case x::Nil => List(carryOver * x)
case x::y::Nil => List(carryOver * x * y, y * x)
case x::y::z::Nil => List(carryOver * x * y, x * z, y * z)
case x::y::z::tail =>
if (useCarryOver) List(carryOver * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
else List(x * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
}
println(multiplication(numbers).mkString(","))
}
array recursion interview-questions functional-programming scala
asked Dec 27 '18 at 23:18
vikrant
787
Given an array of integers, update the index with multiplication of previous and next integers,
Input: 2 , 3, 4, 5, 6
Output: 2*3, 2*4, 3*5, 4*6, 5*6
Following is a scala implementation for the same. Kindly review.
import scala.util.Random
object NeighborMultiplication extends App {
val numbers = List.fill(10)(Random.nextInt(10))
println(numbers mkString ",")
def multiplication(l: List[Int], carryOver: Int = 1, useCarryOver: Boolean = false ): List[Int] = l match {
case Nil => List()
case x::Nil => List(carryOver * x)
case x::y::Nil => List(carryOver * x * y, y * x)
case x::y::z::Nil => List(carryOver * x * y, x * z, y * z)
case x::y::z::tail =>
if (useCarryOver) List(carryOver * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
else List(x * y, x * z, y * tail.head) ++ multiplication(tail, z, true)
}
println(multiplication(numbers).mkString(","))
}
array recursion interview-questions functional-programming scala
array recursion interview-questions functional-programming scala
asked Dec 27 '18 at 23:18
vikrant
787
asked Dec 27 '18 at 23:18
vikrant
787
asked Dec 27 '18 at 23:18
vikrant
787
asked Dec 27 '18 at 23:18
vikrant
787
asked Dec 27 '18 at 23:18
vikrant
787
787
add a comment |
add a comment |
1 Answer
1
active
oldest
votes
The tricky part of this problem is how to handle the special cases for the start and end of the list, as well as how to handle short lists with fewer than three elements.
The fact that you need to consider up to three elements at a time means that you need a lot of base cases for recursion, though. It's also undesirable to expose the special cases in the form of the carryOver and useCarryOver parameters.
A better approach would be to take advantage of the List.sliding function. (Note that .sliding may produce a group with just two elements instead of three, if the input lst has length two.)
def multiplication(lst: List[Int]): List[Int] = lst match {
case _::_::_ =>
(lst.head :: lst ++ List(lst.last))
.sliding(3)
.map(group => group.head * group.last)
.toList
case _ => lst
}
answered Dec 28 '18 at 3:33
200_success
128k15151413
thanks for your answer, sliding fits here beautifully.
– vikrant
Dec 28 '18 at 20:20
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
return StackExchange.using("mathjaxEditing", function () {
StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
});
});
}, "mathjax-editing");
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "196"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f210456%2freplace-array-element-with-multiplication-of-neighbors-in-scala%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
1 Answer
1
active
oldest
votes
1 Answer
1
active
oldest
votes
active
oldest
votes
active
oldest
votes
The tricky part of this problem is how to handle the special cases for the start and end of the list, as well as how to handle short lists with fewer than three elements.
The fact that you need to consider up to three elements at a time means that you need a lot of base cases for recursion, though. It's also undesirable to expose the special cases in the form of the carryOver and useCarryOver parameters.
A better approach would be to take advantage of the List.sliding function. (Note that .sliding may produce a group with just two elements instead of three, if the input lst has length two.)
def multiplication(lst: List[Int]): List[Int] = lst match {
case _::_::_ =>
(lst.head :: lst ++ List(lst.last))
.sliding(3)
.map(group => group.head * group.last)
.toList
case _ => lst
}
answered Dec 28 '18 at 3:33
200_success
128k15151413
thanks for your answer, sliding fits here beautifully.
– vikrant
Dec 28 '18 at 20:20
add a comment |
The tricky part of this problem is how to handle the special cases for the start and end of the list, as well as how to handle short lists with fewer than three elements.
The fact that you need to consider up to three elements at a time means that you need a lot of base cases for recursion, though. It's also undesirable to expose the special cases in the form of the carryOver and useCarryOver parameters.
A better approach would be to take advantage of the List.sliding function. (Note that .sliding may produce a group with just two elements instead of three, if the input lst has length two.)
def multiplication(lst: List[Int]): List[Int] = lst match {
case _::_::_ =>
(lst.head :: lst ++ List(lst.last))
.sliding(3)
.map(group => group.head * group.last)
.toList
case _ => lst
}
answered Dec 28 '18 at 3:33
200_success
128k15151413
thanks for your answer, sliding fits here beautifully.
– vikrant
Dec 28 '18 at 20:20
add a comment |
The tricky part of this problem is how to handle the special cases for the start and end of the list, as well as how to handle short lists with fewer than three elements.
The fact that you need to consider up to three elements at a time means that you need a lot of base cases for recursion, though. It's also undesirable to expose the special cases in the form of the carryOver and useCarryOver parameters.
A better approach would be to take advantage of the List.sliding function. (Note that .sliding may produce a group with just two elements instead of three, if the input lst has length two.)
def multiplication(lst: List[Int]): List[Int] = lst match {
case _::_::_ =>
(lst.head :: lst ++ List(lst.last))
.sliding(3)
.map(group => group.head * group.last)
.toList
case _ => lst
}
answered Dec 28 '18 at 3:33
200_success
128k15151413
The tricky part of this problem is how to handle the special cases for the start and end of the list, as well as how to handle short lists with fewer than three elements.
The fact that you need to consider up to three elements at a time means that you need a lot of base cases for recursion, though. It's also undesirable to expose the special cases in the form of the carryOver and useCarryOver parameters.
A better approach would be to take advantage of the List.sliding function. (Note that .sliding may produce a group with just two elements instead of three, if the input lst has length two.)
def multiplication(lst: List[Int]): List[Int] = lst match {
case _::_::_ =>
(lst.head :: lst ++ List(lst.last))
.sliding(3)
.map(group => group.head * group.last)
.toList
case _ => lst
}
answered Dec 28 '18 at 3:33
200_success
128k15151413
answered Dec 28 '18 at 3:33
200_success
128k15151413
answered Dec 28 '18 at 3:33
200_success
128k15151413
answered Dec 28 '18 at 3:33
200_success
128k15151413
128k15151413
thanks for your answer, sliding fits here beautifully.
– vikrant
Dec 28 '18 at 20:20
add a comment |
thanks for your answer, sliding fits here beautifully.
– vikrant
Dec 28 '18 at 20:20
thanks for your answer, sliding fits here beautifully.
– vikrant
Dec 28 '18 at 20:20
thanks for your answer, sliding fits here beautifully.
– vikrant
Dec 28 '18 at 20:20
add a comment |
Thanks for contributing an answer to Code Review Stack Exchange!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
Use MathJax to format equations. MathJax reference.
To learn more, see our tips on writing great answers.
Some of your past answers have not been well-received, and you're in danger of being blocked from answering.
Please pay close attention to the following guidance:
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f210456%2freplace-array-element-with-multiplication-of-neighbors-in-scala%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
