Develop Reference

Function luckymoney in chinese culture

I have an assessment in JavaScript which is a little bit odd. Here it is:
Goal:
In Chinese culture, it is common during celebrations to give "red
envelopes" containing a little money. Most often, the adult
generations give to the younger generations. You want to build a
WeChat application to help grandparents share their donation budget
between their grandchildren.
Write a program that calculates the number of "lucky gifts" (equal to 8) according to the money budget and the number of giftees grandchildren
Functioning:
Many rules, mixing tradition and superstition, frame this gift:
Donations should not contain amount 4, as it sounds like "dead"
it is auspicious to donate an amount of 8, as it sounds like "fortune"
it would be frowned upon not to give anything to one of the
grandchildren
your algorithm must return the number of donations equal to 8 while
respecting the following rules:
Spend the entire budget (unless there is enough budget to give everyone 8)
Give no 4 (by tradition, the budget will never be 4)
Give no 0 (unless the budget is not sufficient)
Score a maximum of 8 once the above rules are respected
Implementation:
Implement the function luckyMoney(money,giftees) which :
take as inputs the integers money and giftees with:
0 <=money< 100
0 <=giftees<10
and returns the number of donations equal to 8 as an integer
Examples:
Case 1:
Inputs
12
2
Ouput
0
Case 2:
inputs
24
4
Ouput
2
Case 3
Inputs
7
2
Output
0
First of all, I don't quite understand the Case2 of the examples given above, as inputs we have money which is worth 24 and giftees which is equals to 4, after Euclidean division by 8, we get the number of gifts equals to 8 as an integer and 24 divided by 8, we get 3, but why the output is 2 instead of 3.
Did I miss something?
So I went ahead and implement the function as follows:
function luckyMoney(money,giftees){
if (money % 8 ===0){
return (money/8)
}else if(money%4===0){
return 0}
}
In fact I am going in circles and I do not know how to express the different conditions of the functioning part in my code,
Can you give me a hand please?

my attemp
function luckyMoney(money, giftees) {
if (money < 0 || money >= 100) return -1; //incorrect money input
if (giftees < 0 || giftees >= 10) return -2; //incorrect giftees input
if (money >= giftees * 8) return giftees; //spend the entire budget (unless there is enough budget to give everyone 8)
if (money < giftees) return 0; // not enough money
let b = money, g = giftees; // enough budget for giftees left after donating 8 as much as possible
while (b >= 8 + (g - 1) && g > 0) {
b -= 8;
g--;
}
if(g === 1 && b === 4) return 0;
return giftees - g;
}
console.log('inputs: 12 2, result: ', luckyMoney(12,2));
console.log('inputs: 24 4, result: ', luckyMoney(24,4));
console.log('inputs: 7 2, result: ', luckyMoney(7,2));
console.log('inputs: 64 9, result: ', luckyMoney(64,9));
console.log('inputs: 60 8, result: ', luckyMoney(60,8));

Here's a general algorithm you could follow. Hint: you can generalise the steps using a loop.
1. Try to give everyone eight. Does you have enough budget?
Yes: You have found the solution: all giftees get 8
No: Go to step 2
2. Try to give everyone except 1 person 8.
- Do we have enough in the budget? No: Invalid solution, go to step 3
Yes: How much is left over for the 1 person?
Is it 4 or 0?
No: You have found the solution: (giftees - 1)
Yes: Invalid solution, go step 3
3. Try to give everyone except 2 people 8.
- Do we have enough in the budget? No: Invalid solution, go to step 4
Yes: How much is left over for the 2 people?
Is it less than 2 (i.e. enough for 1 each)
No: You have found the solution: (giftees - 2)
Yes: Invalid solution, go to step 4
4. Try to give everyone except 3 people 8.
- Do we have enough in the budget? No: Invalid solution, go to step 5
Yes: How much is left over for the 3 people?
Is it less than 3 (i.e. enough for 1 each)
No: You have found the solution:(giftees - 3)
Yes: Invalid solution, go to step 5
... keep going until you give nobody 8
Some more test cases for you
luckyMoney(64, 8) == 8 e.g. [8,8,8,8,8,8,8,8]
luckyMoney(65, 10) == 7 e.g. [8,8,8,8,8,8,8,7,1,1]
luckyMoney(66, 10) == 8 e.g. [8,8,8,8,8,8,8,8,1,1]
luckyMoney(100, 1) == 1 e.g. [8]

This is a sample of LukyMoney function in C#:
public static int LuckyMoney(int money, int giftees)
{
decimal fortune = 8;
int dist = (int)(money / fortune);
if((giftees - dist) == 1)
return dist - 1;
if(dist > giftees)
return giftees;
return dist;
}

const luckyMoney = (money, giftees) => {
for(let i = 0; i <= giftees; i++){
const moneyleft = money - (giftees-i)*8;
if (i=== 0){
if (moneyleft >= 0){
return giftees-i
}
}
else if(i===1){
if (moneyleft>0 && moneyleft!=4){
return giftees - i
}
}
else{
if (moneyleft>=i){
return giftees -i
}
}
}
}

I think no loop is needed.
In C/ C++ :
size_t lucky_money(size_t money, size_t giftees) {
size_t max_giftees = (money / 8);
if (max_giftees < giftees) {
size_t rest_money = (money % 8);
size_t rest_giftees = (giftees - max_giftees);
// Subtract one giftee if the rest of money is not enough
return (((rest_giftees != 1) || (rest_money != 4))? (max_giftees + ((rest_money < rest_giftees)? -1: 0)): (0 /* dead */));
} else {
return giftees;
}
}
In JavaScript
function lucky_money(money, giftees) {
let max_giftees = Math.floor(money / 8);
if (max_giftees < giftees) {
let rest_money = (money % 8);
let rest_giftees = (giftees - max_giftees);
// Subtract one giftee if the rest of money is not enough
return (((rest_giftees !== 1) || (rest_money !== 4))? (max_giftees + ((rest_money < rest_giftees)? -1: 0)): (0 /* dead */));
} else {
return giftees;
}
}
console.log('inputs: 12 2, result: ', lucky_money( 12, 2)); // 8 + 4 (1 giftee) -> dead, 0
console.log('inputs: 24 4, result: ', lucky_money( 24, 4)); // 2*8 + 8 (2 giftees) -> 2
console.log('inputs: 7 2, result: ', lucky_money( 7, 2)); // 7 (money) < 8 -> 0
console.log('inputs: 64 9, result: ', lucky_money( 64, 9)); // 7*8 + 8 (2 giftees) -> 7
console.log('inputs: 60 8, result: ', lucky_money( 60, 8)); // 7*8 + 4 (1 giftee) -> dead, 0
console.log('inputs: 64 8, result: ', lucky_money( 64, 8)); // 8*8 -> 8
console.log('inputs: 65 10, result: ', lucky_money( 65, 10)); // 7*8 + 9 (3 giftees) -> 7
console.log('inputs: 66 10, result: ', lucky_money( 66, 10)); // 8*8 + 2 (2 giftees) -> 8
console.log('inputs: 100 1, result: ', lucky_money(100, 1)); // 1*8 + 92 (0 giftee) -> 1

60, 8
should be 6 and not 0!
6 * 8 = 48 and the remaining 2 giftee's will get any amount in the remaining 12(6/6)

object Solution extends App {
def f (num: Int, arr: List [Int]): List [List [Int]] =
arr.flatMap (List.fill (num) (_)).combinations (num).toList
def getDons (bd: Int, nf: Int): Int = {
var dist = (8 until budget + 1 by 8).toList
println (dist)
if (dist.length >= nbFils) return nbFils
while (dist.length > 0) {
var restBdTmp = budget - dist.last
println ("rest is : " + restBdTmp)
var restFils = nbFils - dist.length
println ("remaining childs : " + restFils)
var listP = (0 until restBdTmp + 1 by 1).toList
println("choices : " + listP)
println("combinations : "+f (restFils, listP))
var filterF = f (restFils, listP).filter (x =>
x.sum == restBdTmp && !x.contains (4) && !x
.contains (0)) // .filter(i => i.foreach{o => o!=4 && o != 0}
println (filterF)
if (filterF.length != 0) return dist.length
dist = dist.dropRight (1)
}
return 0
}
val budget = 100
val nbFils = 1
println (getDons (budget, nbFils))
}

return $money - $giftees < 7 ? 0 : (($money - $giftees) % 7 === 3 && $giftees - ((int)(($money - $giftees) / 7)) === 1 ? ((int)(($money - $giftees) / 7)) - 1 : min(((int)(($money - $giftees) / 7)), $giftees));

Grading Students in JS with recursion - Range Error

I was trying to work on this hackerrank problem.
Every student receives a grade in the inclusive range from
0-100 to .
Any less than 38 is a failing grade.
Sam is a professor at the university and likes to round each student's according to these rules:
If the difference between grade the and the next multiple of
5 is less than 3, round up to the next multiple of 5. If the value of grade is less than 38, no rounding occurs as the
result will still be a failing grade.
Given the initial value of for each of Sam's students, write code to
automate the rounding process.
My code is:
function gradingStudents(grades) {
const roundup = y => y + 1;
{
if ( grades < 38 || grades % 5 === 0) return grades;
else if ( grades % 5 < 4 && grades % 5 !== 0) return roundup(grades);
}
{
if (roundup % 5 === 0) return roundup;
else { gradingStudents(roundup + 1) }
}
}
gradingStudents(38) // -> 39
I tried to use Math.ceil(grades) inside the variable roundup but output didnt change. So, when you invoke the function with a number that is not before a multiple of 5 (e.g. 43) it returns the proceeding number. However, if it is the number before a multiple of 5 it gives a range error. "maximum call stack size reached."
As far as I got, the code doesnt proceed to the second part. Even if it did, I am not sure if it would fetch the current value of the function roundup when dealing with if statements in the second block.
What do I dont get in here?
Also, this is actually meant for an array output but since I am a beginner I am pretty much okay with this one for the start as well :D .

Javascript solution:
function gradingStudents(grades) {
return grades.map((grade) => {
if (grade > 37) {
const offset = 5 - (grade % 5);
if (offset < 3) {
grade += offset;
}
}
return grade;
});
}

Try this:
function gradingStudents(grades) { //input: 43
var finalGrade;
if(grade < 38)
return grades;
else{
var gradeDif = grades % 5; //3
if(gradeDif > 3){
return grades;
}
else {
return grades + (5 - gradeDif); //Output: 45
}
}
}

One solution calculates the next multiple of 5 no bigger than the grade and uses that value to test whether or not to round up (next5 - grade < 3).
We write a simple function to round an individual grade and then for a list of grades use .map with that function.
const roundGrade = (grade) => {
const next5 = 5 * Math.ceil (grade / 5)
return (grade < 38) ? grade : (next5 - grade < 3) ? next5 : grade
}
const gradingStudents = (grades) =>
grades .map (roundGrade)
console .log (gradingStudents ([73, 67, 38, 33]))
Note that, like most solutions to this problem, no recursion is needed.

1-Use the Array.prototypt.map according to the question logic.
const gradingStudents = (grades) => grades
.map(n => (n >= 38 && n % 5 >= 3)?(n + ( 5 - ( n % 5 ) )):n )
let result = gradingStudents([0,25,38,56,89,77,78,57,58])
console.log(result)

My solution is this
function gradingStudents(grades) {
grades.map((grade,i)=>{
if(grade >= 38){
let fg = (grade/5).toString().split('.');
if(fg[1]>5){
grades[i]=((parseInt(fg[0],10)+1) * 5);
};
}
});
return grades;
}
console.log(gradingStudents([73,67,38,33]));

my solution:
function gradingStudents(grades) {
return grades.map(function(grade) {
return (grade >= 38 && grade % 5 >= 3) ? grade + 5 - (grade % 5) : grade;
});
}

Smallest Common Multiple Code produces the wrong answer on one array

[edit]
I should clarify, I am attempting to find the smallest common multiple of a range of numbers. Sorry about that. I have attempted another solution but I still run into an incorrect answer on the last array [23, 18].
function smallestCommons(arr) {
arr = arr.sort(function (a, b) { return a - b; });
var count = 1;
for (var i = arr[0]; i <= arr[1]; i++) {
if (count % i !== 0) {
i = arr[0];
count++;
}
}
return count;
}
smallestCommons([23,18]);
My solution produces 2018940 when it should be 6056820

Your endless loop is becouse of your inner for loop which starts at the value 19 and runs to 22
414 (smallestMultiple of 18 & 23) % 19 == 15
414 % 20 = 14
414 % 21 = 15
414 % 22 = 18
which leads to your statement if(count % i == 0) being false and your for loop goes on with 415 416 ...
if u want to get the
least common multiple
var isSmallestMultipe = 0;
while(isSmallestMultiple == 0)
{
for(var i = 1; i <= arr[1]; i+)
{
if((arr[0]*i) % arr[1] == 0)
{
isSmallestMultiple = arr[0] * i;
}
}
}

Why is recursive wordsearch solver missing five words yet finding the other 47?

I'm creating a recursive wordsearch app which appears (to my amateur eye) correct yet is missing five of the fifty three words. The words may be hidden left to right, right to left, up, down or diagonally. I want the console to output the found word, x and y coordinates in the puzzle, and direction. I have looked through the code tirelessly and can't seem to find the problem. Please help!
The missing words are:
2: Backup
29: LCD
40: Power Supply
44: Scanner
53: Wireless
Here's the code:
I'm loading the puzzle and word list from textareas:
<textarea name="wordsearch" id="wordsearch" style="display:none">
TPIRCSAVAJLEXIPIGE
LIAMEMORYMMOUSENIL
CRABKSATXINUYHSTFG
DNDIRECTORYETAOEOO
POWERSUPPLYNIRFRLO
UCOASAEVASCCRETNDG
KIROPKTYPSHRUWWEEL
CDDECPREEAHYCAATRM
ANRIMALLTDRPERREAT
BOLENMEIEKETSEEPHH
RCKIPRAFCVRIIRSULM
EEBEIARRIABOOTMBOR
NSTWRAPRGRTNWBINGO
NOOSGNDLOODINTIOIS
ANGMAKAULARAOTEANR
CAEASPTLTAIPONRNDU
SNFIREWALLWREIKOOC
TFDPRDHTOOTEULBYTE</textarea>
<textarea name="wordlist" id="wordlist" style="display:none">
Application
Backup
Binary
Bluetooth
Boot
Byte
Chat
Click
Cookie
Cursor
Data
Defragment
Directory
Disk drive
DOS
Drag
Email
Encryption
File
Firewall
Folder
GIF
Google
HTML
Icon
Internet
JavaScript
Kernal
LCD
Login
Memory
Monitor
Mouse
Nanosecond
Network
Partition
Paste
PDF
Pixel
Power Supply
Programmer
Router
Save As
Scanner
Security
ShareWare
Software
Spam
Taskbar
Thumbnail
UNIX
Wallpaper
Wireless</textarea>
<script src="wordsearch.js" type="text/javascript"></script>
And the javascript:
(function() {
var puzzle = [];
var rows = 0;
var columns = 0;
var words = [];
var foundWordsArray = [];
var foundWordsObj = {
word: "",
coordinates: {
x: 0,
y: 0
},
direction: ""
};
window.onload = function() {
puzzle = document.getElementById("wordsearch").value.split("\n").map(function(p) {
return p.toUpperCase();
});
words = document.getElementById("wordlist").value.split("\n").map(function(w) {
return w.toUpperCase().replace(/\s/g, '');
});
rows = puzzle.length;
columns = puzzle[0].length;
solvePuzzle();
};
function solvePuzzle() {
var wFound = []; // list of words that were found
var res = false; // was word found in any direction
var wL = words.length;
// console.log(wL);
var i = 0; // index for the words
var j = 0; // index for the puzzle rows
var k = 0; // index for the puzzle columns
var fChar = ''; // first character
for (i = 0; i < wL; ++i) {
fChar = words[i].charAt(0);
wordFound:
for (j = 0; j < rows; ++j) {
for (k = 0; k < columns; ++k) {
if (fChar == puzzle[j].charAt(k + 1)) {
// found first character
//left
res = findWordLeft(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "RL");
break wordFound; // found a word, break to wordFound
}
//Right
res = findWordRight(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "LR");
break wordFound; // found a word, break to wordFound
}
//Up
res = findWordUp(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "U");
break wordFound; // found a word, break to wordFound
}
//Down
res = findWordDown(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "D");
break wordFound; // found a word, break to wordFound
}
//UpLeft
res = findWordUpLeft(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "DUL");
break wordFound; // found a word, break to wordFound
}
//UpRight
res = findWordUpRight(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "DUR");
break wordFound; // found a word, break to wordFound
}
//DownLeft
res = findWordDownLeft(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "DDL");
break wordFound; // found a word, break to wordFound
}
//DownRight
res = findWordDownRight(words[i], 1, words[i].length, j, k + 1);
if (false !== res) {
// console.log(i + 1, words[i], (k + 2), (j + 1), "DDR");
break wordFound; // found a word, break to wordFound
}
}
}
}
}
}
function findWordLeft(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (k > 0 && word.charAt(posW) == puzzle[j].charAt(k - 1)) {
result = findWordLeft(word, posW + 1, wordL, j, k - 1);
if (result !== false) {
return new Array(j, k - 1);
}
}
return result;
}
function findWordRight(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (k < columns && word.charAt(posW) == puzzle[j].charAt(k + 1)) {
result = findWordRight(word, posW + 1, wordL, j, k + 1);
if (result !== false) {
return new Array(j, k + 1);
}
}
return result;
}
function findWordUp(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (0 <= (j - 1) && word.charAt(posW) == puzzle[j - 1].charAt(k)) {
result = findWordUp(word, posW + 1, wordL, j - 1, k);
if (result !== false) {
return new Array(j - 1, k);
}
}
return result;
}
function findWordDown(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (rows > (j + 1) && word.charAt(posW) == puzzle[j + 1].charAt(k)) {
result = findWordDown(word, posW + 1, wordL, j + 1, k);
if (result !== false) {
return new Array(j + 1, k);
}
}
return result;
}
function findWordUpLeft(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (0 < k && 0 < j && word.charAt(posW) == puzzle[j - 1].charAt(k - 1)) {
result = findWordUpLeft(word, posW + 1, wordL, j - 1, k - 1);
if (result !== false) {
return new Array(j - 1, k - 1);
}
}
return result;
}
function findWordUpRight(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (columns > k && 0 < j && word.charAt(posW) == puzzle[j - 1].charAt(k + 1)) {
result = findWordUpRight(word, posW + 1, wordL, j - 1, k + 1);
if (result !== false) {
return new Array(j - 1, k + 1);
}
}
return result;
}
function findWordDownLeft(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (rows > (j + 1) && 0 < k && word.charAt(posW) == puzzle[j + 1].charAt(k - 1)) {
result = findWordDownLeft(word, posW + 1, wordL, j + 1, k - 1);
if (result !== false) {
return new Array(j + 1, k - 1);
}
}
return result;
}
function findWordDownRight(word, posW, wordL, j, k) {
var result = false;
if (posW == wordL) { // check if all characters were found
return true;
}
if (rows > (j + 1) && columns > k && word.charAt(posW) == puzzle[j + 1].charAt(k + 1)) {
result = findWordDownRight(word, posW + 1, wordL, j + 1, k + 1);
if (result !== false) {
return new Array(j + 1, k + 1);
}
}
return result;
}
})();
Here is what I get from the console:
1 "APPLICATION" 4 6 "DDR"
3 "BINARY" 3 12 "DUR"
4 "BLUETOOTH" "RL" 15 18
5 "BOOT" 11 12 "LR"
6 "BYTE" 15 18 "LR"
7 "CHAT" 12 6 "DDL"
8 "CLICK" 2 11 "DUR"
9 "COOKIE" "RL" 18 17
10 "CURSOR" 18 17 "U"
11 "DATA" 11 14 "DDL"
12 "DEFRAGMENT" 10 9 "DDL"
13 "DIRECTORY" 3 4 "LR"
14 "DISKDRIVE" 3 18 "DUR"
15 "DOS" 3 8 "DUR"
16 "DRAG" 6 18 "DUL"
17 "EMAIL" "RL" 5 2
18 "ENCRYPTION" 12 4 "D"
19 "FILE" 8 11 "U"
20 "FIREWALL" 3 17 "LR"
21 "FOLDER" 17 3 "D"
22 "GIF" 17 1 "D"
23 "GOOGLE" 18 6 "U"
24 "HTML" 18 10 "U"
25 "ICON" 2 7 "U"
26 "INTERNET" 16 1 "D"
27 "JAVASCRIPT" "RL" 10 1
28 "KERNAL" 3 11 "DDR"
30 "LOGIN" 17 11 "D"
31 "MEMORY" 4 2 "LR"
32 "MONITOR" 18 11 "DDL"
33 "MOUSE" 11 2 "LR"
34 "NANOSECOND" 2 17 "U"
35 "NETWORK" 16 16 "DUL"
36 "PARTITION" 9 7 "DDR"
37 "PASTE" 6 16 "DUL"
38 "PDF" "RL" 4 18
39 "PIXEL" "RL" 15 1
41 "PROGRAMMER" 12 16 "DUL"
42 "ROUTER" 10 13 "DDL"
43 "SAVEAS" "RL" 10 6
45 "SECURITY" 13 10 "U"
46 "SHAREWARE" 14 2 "D"
47 "SOFTWARE" 15 3 "D"
48 "SPAM" 15 11 "DUR"
49 "TASKBAR" "RL" 8 3
50 "THUMBNAIL" 18 9 "DDL"
51 "UNIX" "RL" 12 3
52 "WALLPAPER" 11 17 "DUL"

There seems to be something off with the way you indexing or the way you check for the boundaries. To be honest, I can't exactly tell you what the problem is, but I have a working version which is much shorter and with less code repetition. Maybe you can take something from that.
function solvePuzzle() {
// list of words that were found
var wFound = [];
console.log("Number of words:", words.length);
// loop over words
for (var i = 0; i < words.length; ++i) {
var fChar = words[i].charAt(0);
wordFound:
// loop over characters
for (var j = 0; j < rows; ++j) {
for (var k = 0; k < columns; ++k) {
// check first character
if (fChar == puzzle[j].charAt(k)) {
// iterate over all 9 directions
for (var dj = -1; dj <= 1; dj++) {
for (var dk = -1; dk <= 1; dk++) {
// skip invalid direction
if (dj == 0 && dk == 0) continue;
// try to find word
if (findWord(words[i], 0, j, k, dj, dk)) {
console.log(i + 1, words[i], k + 1, j + 1, getDirectionString(dj, dk));
// found a word
wFound.push(words[i]);
break wordFound;
}
}
}
}
}
}
}
console.log("Number of words found:", wFound.length);
}
function findWord(word, posW, j, k, dj, dk) {
// check if all characters were found
if (posW == word.length) return true;
// check if position is outside the boundaries
if (j < 0 || j >= rows || k < 0 || k >= columns) return false;
// check if current character fails to match the word
if (word.charAt(posW) != puzzle[j].charAt(k)) return false;
// check next character
return findWord(word, posW + 1, j + dj, k + dk, dj, dk);
}
function getDirectionString(dj, dk) {
switch (dj) {
case -1: switch (dk) { case -1: return "DUL"; case 0: return "U"; case 1: return "DUR"; } break;
case 0: switch (dk) { case -1: return "RL"; case 1: return "LR"; } break;
case 1: switch (dk) { case -1: return "DDL"; case 0: return "D"; case 1: return "DDR"; } break;
}
return "invalid";
}
The output is:
Number of words: 53
1 "APPLICATION" 4 6 "DDR"
2 "BACKUP" 1 10 "U"
3 "BINARY" 3 12 "DUR"
4 "BLUETOOTH" 15 18 "RL"
5 "BOOT" 11 12 "LR"
6 "BYTE" 15 18 "LR"
7 "CHAT" 12 6 "DDL"
8 "CLICK" 2 11 "DUR"
9 "COOKIE" 18 17 "RL"
10 "CURSOR" 18 17 "U"
11 "DATA" 11 14 "DDL"
12 "DEFRAGMENT" 10 9 "DDL"
13 "DIRECTORY" 3 4 "LR"
14 "DISKDRIVE" 3 18 "DUR"
15 "DOS" 3 8 "DUR"
16 "DRAG" 6 18 "DUL"
17 "EMAIL" 5 2 "RL"
18 "ENCRYPTION" 12 4 "D"
19 "FILE" 8 11 "U"
20 "FIREWALL" 3 17 "LR"
21 "FOLDER" 17 3 "D"
22 "GIF" 17 1 "D"
23 "GOOGLE" 18 6 "U"
24 "HTML" 18 10 "U"
25 "ICON" 2 7 "U"
26 "INTERNET" 16 1 "D"
27 "JAVASCRIPT" 10 1 "RL"
28 "KERNAL" 3 11 "DDR"
29 "LCD" 1 2 "D"
30 "LOGIN" 17 11 "D"
31 "MEMORY" 4 2 "LR"
32 "MONITOR" 18 11 "DDL"
33 "MOUSE" 11 2 "LR"
34 "NANOSECOND" 2 17 "U"
35 "NETWORK" 16 16 "DUL"
36 "PARTITION" 9 7 "DDR"
37 "PASTE" 6 16 "DUL"
38 "PDF" 4 18 "RL"
39 "PIXEL" 15 1 "RL"
40 "POWERSUPPLY" 1 5 "LR"
41 "PROGRAMMER" 12 16 "DUL"
42 "ROUTER" 10 13 "DDL"
43 "SAVEAS" 10 6 "RL"
44 "SCANNER" 1 17 "U"
45 "SECURITY" 13 10 "U"
46 "SHAREWARE" 14 2 "D"
47 "SOFTWARE" 15 3 "D"
48 "SPAM" 15 11 "DUR"
49 "TASKBAR" 8 3 "RL"
50 "THUMBNAIL" 18 9 "DDL"
51 "UNIX" 12 3 "RL"
52 "WALLPAPER" 11 17 "DUL"
Number of words found: 52

Pagination algorithm working incorrectly

I've got a fairly simple pagination algorithm here but it's not working the way I'd like it to.
Currently it's displaying like this
1 2 3 ... 33 34 35 [36] 37 38 ... 47 48 49 50
When it should be displaying like this
1 2 3 ... 33 34 35 [36] 37 38 39 ... 48 49 50
Here's my code, I wrote it very quickly. It also seems to continuously run (The loop doesn't stop) but I've no idea why.
$(function(){
var pages = 50; //Total number of pages
var current = 36; //The current page we are on
var before = 3; //Number of links to display before current
var after = 3; //Same as above but after
var start = (current - before); //The number of the first link
var end = (current + after); //Number of the end link
for(var i = 1; i <= pages; i++){
if(i == (before + 1)){
i = start;
document.write('...');
}
else if(i == (current + after)){
i = (pages - after);
document.write('...');
}
if(i == current){
document.write(' ['+i+'] ');
}
else{
document.write(' '+i+' ');
}
}
});

If (current + after) > (pages - after) and (current + after) < pages then this code will run forever because of:
else if(i == (current + after)){
i = (pages - after);
document.write('...');
}
Each time i reaches current + after, it will be reduced to pages - after and that cycle will continue indefinitely

Please fix after to after + 1 in 2 places in all places in your loop where you use it.
Also, I am not sure your code will work correctly for edge cases (e.g. where current == 2) - you may want to test that

current + after is 39 (36 + 3) here, so no wonder it displays "..." instead of 39, increase "after" by 1 to fix this
after looking at the code for several minutes, I don't have a clue why it should run forever :) Have you tried writing "i" to the console to check what values it takes and why it never reaches its "final value"?

There is a reason why arrays used zero-based indexing in most languages: the math is just simpler. In your case, since you obviously can't use zero-based indexing, you'll just have to fix the off-by-one errors:
else if(i == (current + after + 1)){
i = (pages - after + 1);
document.write('...');
}

The following algorithm gives 5 pages around the current page
Example:
- [X] is the current page
- In this case the total pages are 20
<[1] 2 3 4 5>
<1 [2] 3 4 5>
<1 2 [3] 4 5>
<2 3 [4] 5 6>
... numbers in between ...
<15 16 [17] 18 19>
<16 17 [18] 19 20>
<16 17 18 [19] 20>
<16 17 18 19 [20]>
Or in case total pages are less than 5, say 3...
The results look like
<[1] 2 3>
And so on.
function (page, totalPages) {
var leftBoundry = Math.max(1, page - 2)
var rightBoundry = Math.min(totalPages, page + 2)
var arr = []
var emptyRight = 2 - (rightBoundry - page)
var emptyLeft = 2 - (page - leftBoundry)
leftBoundry = Math.max(1, leftBoundry - emptyRight)
rightBoundry = Math.min(totalPages, rightBoundry + emptyLeft)
for (var i = leftBoundry; i <= rightBoundry; i++) {
arr.push(i)
}
return arr;
}
.