Counting Fingers

June 16, 2020

The little girl will be on her thumb on 1, 9, 17, and every 8k+1, whereupon the pattern repeats itself:

(define (finger n)
  (case (modulo n 8)
    ((1  ) 'thumb)
    ((2 0) 'index)
    ((3 7) 'middle)
    ((4 6) 'ring)
    ((5  ) 'pinkie)))

She will be on her index finger when she reaches a thousand:

> (finger 1000)
index

You can run the program at https://ideone.com/38BHgj.

Posted by programmingpraxis

Filed in Exercises

14 Comments »

14 Responses to “Counting Fingers”

matthew said
June 16, 2020 at 11:02 AM
I presume that should be: “counts 10 on her index finger, 11 on her middle finger, and so on”
programmingpraxis said
June 16, 2020 at 12:11 PM
Correct. Fixed. Thank you.
Zack said
June 16, 2020 at 12:57 PM
Here is my take on Julia: https://pastebin.com/NLWPwL5C

Cool drill for getting acquainted with modulo arithmetic. Cheers!
Mark said
June 16, 2020 at 1:43 PM
```
"timrprmip"[(999-1)%8]
```

Jan Van lent said

June 17, 2020 at 10:32 AM

f = lambda n: 4-abs(4-(n-1)%8)
print(f(1000))
print("timrp"[f(1000)]) # see Mark's solution

Xero said
June 18, 2020 at 5:03 AM
My thorouhly documented solution implemented in SML can be found at <ahref=”https://pastebin.com/HQ5WkqKx”>. It takes a different approach from modular arithmetic.
Maksym Fedenko said
June 19, 2020 at 7:45 PM
Hi, I’m beginner, can I resolve task in this way?

public class Exercises1 {
public static void main(String[] args) {
Solution solution = new Solution();
while (solution.getCounter_fingers() < 1006586890){
solution.setCounter_fingers(solution.getCounter_fingers() + 4);
solution.setCounter_iterations(solution.getCounter_iterations() + 1);
}
System.out.println(solution.getCounter_iterations());
solution.setCounter_fingers(solution.getCounter_fingers() – 1);
if(solution.getCounter_iterations() % 2 == 0){
System.out.println(“Girl stop count on index finger”);
}else {
System.out.println(“Girl stop count on ring finger”);
}
}
```
public static class Solution {
    private int counter_fingers = 5;
    private int counter_iterations = 1;
    public int getCounter_fingers() {
        return counter_fingers;
    }
    public void setCounter_fingers(int counter_fingers){
        this.counter_fingers = counter_fingers;
    }
    public int getCounter_iterations() {
        return counter_iterations;
    }
    public void setCounter_iterations(int counter_iterations) {
        this.counter_iterations = counter_iterations;
    }
}
```
Larry Lee said
June 30, 2020 at 7:46 PM
Using Spanish abbreviations for finger names (Haskell): finger n = ['i', 'p', 'i', 'm', 'a', 'c', 'a', 'm'] !! (nmod8)

Andrey Orst said

July 5, 2020 at 6:10 PM

Here’s Clojure solution with infinity lazy sequence of fingers :)

(defn counting-fingers [n]
  (let [fingers (cycle [:thumb :index :middle :ring
                        :pinky :ring :middle :index])]
    (first (drop (dec n) fingers))))

Andrey Orst said

July 5, 2020 at 6:23 PM

(defn counting-fingers [n]
  ([:thumb :index :middle :ring
    :pinky :ring :middle :index] (mod (dec n) 8)))

Daniel said

July 14, 2020 at 11:55 PM

Here’s a solution in C.

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[]) {
  assert(argc == 2);
  int x = atoi(argv[1]);
  assert(x > 0);
  char finger = "timrprmi"[(x - 1) % 8];
  printf("%c\n", finger);
  return EXIT_SUCCESS;
}

Usage:

$ ./a.out 1000
i

Antonio Leonti said
July 21, 2020 at 1:34 AM
I took a very different approach from you all– my original thought was to just use x%8, but I decided to instead use the absolute value of a triangle wave. At least I thought it was neat.
```
int finger(int x){
    return (int)(fabs(8/M_PI * asin(sin(M_PI*(x-1) / 8)))+0.5);
}
int main(){
    printf("%c\n", "TIMRP"[finger(1000)]);
}
```

Daniel said

July 21, 2020 at 3:36 AM

Here’s a Python solution inspired by @Antonio’s solution, adapted to use integers in place of floating point.

def finger(x):
    return 'timrp'[abs(8 * ((x + 3) // 8) - x + 1)]

for x in range(1, 11):
    print(x, finger(x))
print(1000, finger(1000))

Output:

1 t
2 i
3 m
4 r
5 p
6 r
7 m
8 i
9 t
10 i
1000 i

Hakan said

August 12, 2020 at 12:02 AM

In my approach, I took advantage of array pointers in PHP. Every time the pointer reaches an outer finger (thumb/pinky), the array elements are reversed in order. You simply scroll down to see the finger that is declared at count number 1000.

<?php

// Put your fingers in the array
$fingers = [
	'thumb',
	'index',
	'middle',
	'ring',
	'pinky',
];


for ($i = 1; $i <= 1000; $i++) { 
	// Declare both the count and finger with each iteration
	echo $i.". ".current($fingers)."<br>";
	// Move the array pointer up one element
	next($fingers);
	// If the array pointer is at either the pinky or the thumb
	if (current($fingers) == 'pinky' || current($fingers) == 'thumb') {
		// reverse the order of the elements in the array
		$fingers = array_reverse($fingers);
	}
}

?>

Programming Praxis