I have a number like this:
n = 548915381
The output should be the sum of every second digit of that number. In this case 26:
4+9+5+8 = 26
Rules:
Test cases:
| Input | Output |
|---|---|
| 10 | 0 |
| 101011 | 1 |
| 548915381 | 26 |
| 999999 | 27 |
| 2147483647 | 29 |
| 999999999 | 36 |
y∑
well.
Try it Online! | 1 byte with s
Explanation
y∑
y Uninterleave, push two lists with every second and every second+1 digit
∑ Sum the first list
s solution not primary?
\$\endgroup\$
-1 by @l4m2
f=n=>n&&f(i=n/10|0)+i++%2*n%10
f=n=>n?f(n/10|0)+i++%2*n%10:i=0
f = n => // f is a recursive function taking the input n
n ? // if n is not equal to 0:
f(n / 10 | 0) + // do a recursive call with floor(n / 10)
// it's important to understand that:
// 1) n is defined in the local scope of f
// 2) i is defined in the global scope
// 3) we're not going to execute the code that
// follows until the recursion stops and i
// has been initialized
i++ % 2 * // take the parity of i (increment it afterwards)
n % 10 // and multiply by the least significant decimal
// digit of n
: // else:
i = 0 // stop the recursion and initialize i to 0
lambda n:sum(map(int,str(n)[1::2]))
Assuming input is a string number
for _ c (`fold -1`)let t+=c;<<<$t
-3 bytes thanks to roblogic
Inputs as a string, because there is no way to input as a number in Zsh.
for j k (${(s::)1})((s+=k));<<<$s for 33 bytes...
\$\endgroup\$
=SUM(--(0&MID(A1,2*ROW(A:A),1)))
\$\endgroup\$
Commented
Dec 19, 2022 at 20:34
$+@SUWa
First pip answer, so don't sue me plz.
Explanation
$+@SUWa
@SUWa Uninterweave a, take the second item of the two "every second element" lists
$+ Sum the string
$+@RUWa or $+DQUWa. (Also, $+*SUWa and S$+*UWa technically output as a singleton list, but it looks the same without flags.)
\$\endgroup\$
S returns all but the first item (SUW = S UW).
\$\endgroup\$
0i~i:c%@0(?n+!
Explanation
0 # init sum as 0
i~ # discard an input
i: # duplicate an input
c%@ # mod the copy by 12 and move down on stack
0(?n # if the other copy was negative, print the sum
+! # else add copy to sum and skip the next instruction
-8 bytes thanks to G B
-1 byte thanks to Armand Fardeau
->n{eval"#{n}".scan(/.(.)/)*?+}
-n flag: gsub(/.(.)/){$.+=eval$1};p$.-1
\$\endgroup\$
->n{eval"#{n}".scan(/.(.)/)*?+} tio.run/##KypNqvz/v0BBw0hPzzDVTFMvN7GgWiHeUEFfwVChpgbCAhK1//…
\$\endgroup\$
Commented
Dec 23, 2022 at 22:39
All credit goes to Raul.
[:+/_2}.\,.&.":
[:+/_2}.\,.&.":
,.&.": NB. equivalent to ". ,. ": y, convert to digit list
_2}.\ NB. behead each non-overlapping window of size 2
[:+/ NB. sum the resulting column
1(#.]*0 1$~#),.&.":
Updated to reflect challenge requirements. Thanks to Jonah for the modifications.
1(#.]*0 1$~#),.&.":
,.&.": NB. same as above
1( ) NB. dyadic hook
# NB. use length of right arg to
0 1$~ NB. reshape 0 1, reuses elements to create alternating 1's
]* NB. multiply by the right arg
#. NB. 1 #. y sums the result
10&#.inv would be required to convert to digits beforehand
\$\endgroup\$
Commented
Dec 22, 2022 at 21:57
1(#.]*0 1$~#),.&.": adapts your approach to the number input requirement.
\$\endgroup\$
&. here @Jonah. Will update.
\$\endgroup\$
+/(=\0&)#10\
10\ convert (implicit) input integer to a list of its digits(=\0&)# only keep elements at odd indices (0-indexed); literally, take the minimum of the digits and 0 (to zero-out every value), then use =\ (equals-scan) to generate a bit mask with 1s in odd indices and 0s in even ones+/ calculate (and implicitly return) the sum
tssM%2+1z
+1z # Append '1' before the input
%2 # Every 2nd element of
ssM # Map to integer and take sum
t # Decrease by 1
D0ÐoS
Also 5 bytes
DŻm2S
Also also 5 bytes
Ds2SṪ
D0ÐoS - Main link. Takes an integer on the left
D - Digits
Ðo - To digits in odd positions:
0 - Set them to 0
S - Sum
DŻm2S - Main link. Takes an integer on the left
D - Digits
Ż - Prepend a zero
m2 - Take every second element
S - Sum
Ds2SṪ - Main link. Takes an integer on the left
D - Digits
s2 - Slice into pairs
S - Sums
Ṫ - Tail
math.unicode, 25 bytes[ >dec <odds> 48 v-n Σ ]
! 548915381
>dec ! "548915381"
<odds> ! "4958"
48 ! "4958" 48
v-n ! { 4 9 5 8 }
Σ ! 26
f(n,[i=1])=>[for(;i<(n='$n').length;i+=2)int.parse(n[i])].reduce((v,e)=>v+e);
.(.?)
$1$*
.
Try it online! Link includes test cases. Takes input as a string because Retina has no integer types. Explanation:
.(.?)
$1$*
Convert alternate digits to unary, dropping the other digits.
.
Take the sum and convert back to decimal.
ＩΣΦＳ﹪κ²
Try it online! Link is to verbose version of code. Explanation:
Ｓ Cast the input to string
Φ Filter characters where
κ Current index
﹪ ² Is odd
Σ Take the sum
Ｉ Cast to string
Implicitly print
Use -o to loop over command line arguments. Global matching regexp returns every other character, in this case digit. By default List::Util::sum is imported, e(cho) its result. On the blog, hover the ▶ button, or the blue code box, to see the result:
pl -o 'e sum/.(.)/g' 10 101011 548915381 999999 2147483647 999999999
1⊑·+˝⌊‿2⥊'0'-˜•Fmt
Anonymous tacit function that takes a number and returns a number. Try it at BQN online!
1⊑·+˝⌊‿2⥊'0'-˜•Fmt
•Fmt Format as string
'0'-˜ Subtract '0' character from each, giving a list of digits as numbers
⌊‿2⥊ Reshape into an array with two columns, dropping the last digit if
there is an odd number of digits
·+˝ Sum down each column
1⊑ Take the element at index 1 (0-indexed) in the resulting list
2/`1.: map +/
For testing purposes:
"548915381" ; n>o
2/`1.: map +/
Prettified code:
2/` 1.: map +/
2/` chunk into pairs1.: map get second element of each pair+/ sum
S]y
Port of Vyxal.
S]y
# Uninterleave
] # Get last
S # Sum
S-n2'0
My original answer before seeing Vyxal.
S-n2'0 # Input as a digit list
n # For every
2 # Second item
' # Replace
0 # With a 0
- # Subtract this from the original list
S # Sum
{it.map{it.code-48}.foldIndexed(0){i,a,c->i%2*c+a}}
No TIO link as it doesn't have an updated version, ATO borks with it for some reason.
{it.map{it.code-48}.foldIndexed(0){i,a,c->i%2*c+a}} // String input
{ } // Lambda expression
it.map{it.code-48} // Subtract 48 from each char, turning the string into a list of digits
.foldIndexed(0){i,a,c-> } // Fold over the list, starting with 0. i is the index, a is accumulator, and c is the digit
i%2*c // Multiply the current digit by the index mod 2. If it is even, it resolves to 1*c, otherwise 0*c
+a // Add to accumulator