Code Golf Stack Exchange is a question and answer site for programming puzzle enthusiasts and code golfers. It only takes a minute to sign up.
Sign up to join this community
As input you have:
NAnd you should output:
1 -> 0
2 -> 1
5 -> 1
10 -> 1
12 -> 2
20 -> 2
30 -> 3
54 -> 6
97 -> 10
100 -> 10
It is a code-golf so the lowest score in bytes wins!
8|+10|/
Using RGS's method
8|+ # Add 8 (Parse string implcit)
10|/ # Divide by 10
riq[~GO2CN
ri # Read int
q[~ # Boxed tail (last digit)
GO # Generate from 1, N
2CN # Count number of 2's
$'main'
-0(!a!)-/-(a)ia(!a!)\
#od[01]a*8(a)-\ /e-----@
@-(!a!)/ >-
\m(a)[01]--/
0(!a!) Put 0 into variable "a"
(a)ia(!a!) Add "a" with input (one number at a time), put into variable "a"
e check if it's EOF, then go left or right at the next junction
if false:
[10](a)m(!a!) multiply "a" by 10, put into variable "a"
if true:
(a)8a[10]do# add a with 8, then divide by 10, print the output. Fin.
The rest of symbols are tracks
f(N)->(N+8)div 10.
f(N)-> % Function taking N as input
(N+8) % Add input by 8
div 10. % Floor division by 10
=SUM(1*(RIGHT(ROW(OFFSET(A1,0,0,A1)))="2"))
OFFSET(A1,0,0,A1) generates a range starting at A1 that is A1's value rows tall.
ROW(OFFSET(~)) returns an array of row numbers for that range (\$[1,N]\$).
RIGHT(ROW(~)) returns an array of the right-most character of those row numbers as a string.
RIGHT(~)="2" returns an array of TRUE or FALSE.
1*(~) transforms TRUE to 1 and FALSE to 0.
SUM(~) sums.
8+ij∖
the easy solution.
Ms, 6 bytesƛSt\2=
-2 bytes from Lyxal.
ƛSt\2=
ƛ map range 1..n to the following:
S convert to string
t get last character
\2= is it equal to '2'?
sum the results(s flag)
ƛSt\2=with s flag as well. i.e. Vyxal, Ms, 6 bytes
\$\endgroup\$
+₈k
Since Brachylog likes to treat integers as lists of decimal digits when appropriate, the "remove last element" builtin k can be used to floor-divide by 10.
((i-1)/10)ceil instead of ((i+8)/10)floor
\$\endgroup\$
[ 8 + 10 /i ]
It's a quotation (anonymous function) that adds 8 to its input and then (integer) divides it by 10.
⌊.1*#+.8⌋&
RGS did most of the work by coming up with the clever function to determine the answer. Putting it into Wolfram Langage was then trivial.
NB:
⌊ = \[LeftFloor] = U+230A (3 bytes)
⌋ = \[RightFloor] = U+230B (3 bytes)
8+I/
This is a dc "function": it pops the input from the stack, and then pushes the output onto the stack. (dc is a stack-based language.)
To call it, enter the desired input first (to push it on the stack), follow with the code above, and then enter p to print the output.
dc<<<$1d8+I/p
The input is passed as an argument, and the output is printed.
(This just uses my dc answer internally.)
$1=int($1/10+.8)e
This substitutes the input $1 for the formula int($1/10+.8), and also appends the e variable, which is null (not defined variables return null). This causes $1 to become a string, preventing the expression from evaluating 0 when input is 0 or 1. A false pattern wouldn't allow the line to be printed (0 is false).
f(n){n=(n+8)/10;}
Which works only if optimizations are turned off (more info).
If you love optimizations, then I got this 18 bytes solution for you:
#define N (n+8)/10
int f(int n){return(n+8)/10;}
\$\endgroup\$
Jan 10, 2021 at 17:34
int(.1(N+8
There are a handful of equivalent solutions here because of the number of ways you can do implicit multiplication by .1 - there's also a solution available using the default value of Xmax from the graphscreen variables.
int(.1N+.8
int(N/Xmax+.8
->x{(1..x).to_a.map{|e|(e%10)==2?1:0}.sum}
I don't use Ruby very often, I'm sure it can be golfed further.
