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
The challenge is to golf a program when given a string composed of any number of asterisks, then a comma, than any number of asterisks, say which side has more.
The asterisk-strings can be empty.
0 for ties.
1 for the left.
2 for the right.
Input: ***,**** Output: 2
Input: ***, Output: 1
Input: ***,*** Output: 0
Input: , Output: 0
This is code-golf. Shortest answer wins.
/*,*/,//,*/2//*,/1//,/0//*//
Found out most of my program was unnecessary, -32 bytes.
I made this program when I was learning the language, and decided to post it as a question.
Â.S(3%
Note that ',' is greater than '*'.
Â.S(3%
 - input, reversed(input) (say a, b)
.S - compare: 1 if a > b; -1 if a < b; 0 if a = b
( - negate
3 - push three
% - modulo
Saved a 10 bytes thanks to dingledooper!!!
Saved a byte thanks to ceilingcat!!!
Saved 7 bytes thank to l4m2!!!
f(c){c=strlen(c)-strspn(c,"*")*2;c=c>1?2:c!=1;}
*,*=@cmps{*;*;2;0;1}
Sample run:
bash-5.0$ echo -n '***,****' | gema '*,*=@cmps{*;*;2;0;1}'
2
Solution:
{2/c<|c:#'","\x}
Explanation:
{2/c<|c:#'","\x} / the solution -> e.g. 1 e.g. 2 e.g. 3
{ x} / lambda taking implicit 'x' -> "***,****" "***," "***,***"
","\ / split string on comma -> ("***";"****") ("***";"") ("***";"***")
#' / count length of each -> 3 4 3 0 3 3
c: / store as c -> 3 4 (noop) 3 0 3 3
| / reverse it -> 4 3 0 3 3 3
c< / is c less than this? -> 1 0 0 1 0 0
2/ / convert from base 2 -> 2 1 0
Extra:
2/c<|c:#'","\
,ṚMḄ2c
A monadic Link accepting a list of characters which yields an integer in \$[0,2]\$.
Note that ',' is greater than '*'.
,ṚMḄ2c - Main Link: s e.g.: "*," ",*" ","
Ṛ - reverse (s) ",*" "*," ","
, - pair (s) with (that) ["*,",",*"] [",*","*,"] [",",","]
M - indices of maximal values [2] [1] [1,2]
Ḅ - convert from base 2, say x 2 1 4
2 - two 2 2 2
c - (2) choose (x) - i.e. binomial(2,x) 1 2 0
- implicit print (a list with a single element prints the element)
(⊥⍋|⍒)⊢⍮⌽
(⊥⍋|⍒)⊢⍮⌽ ⍝ left '*,' | right ',*' | equal ','
⊢⍮⌽ ⍝ Length-2 nested vector of self and reverse
⍋ ⍝ Grade up; order of indices to make it ascending-sorted
⍝ 1 2 | 2 1 | 1 2
⍒ ⍝ Grade down; order of indices to make it descending-sorted
⍝ 2 1 | 1 2 | 1 2
| ⍝ Right modulo left
⍝ 0 1 | 1 0 | 0 0
⊥ ⍝ From base 2 to integer
⍝ 1 | 2 | 0
','".
\$\endgroup\$
Whooping -6 thanks to @Bubbler.
(⊃3|⍒-⍋)⊂,⊂∘⌽
Try it online! This should be golfable as there are some things I am repeating there but I am not sure how to do it yet.
{3|×1+(2×⍵⍳',')-≢⍵}
Saved 1 byte thanks to @tsh
Taking advantage of the looser output rules: this versions returns 0 for ties, undefined for left or * for right.
s=>(s+0)[s.search`,`*2+1]
Returns a Boolean value instead of 0 / 1.
s=>([a,b]=s.split`,`,a<b?2:a>b)
~/,/;p ($`<=>$')%3
Takes input from STDIN. Compares the regex match groups $` and $', which are set equal to everything on the left and right of the comma, respectively.
-[>>,<--[>-<++++++]>-]<+[<<,]>[<-->+[<+>+]]-[<+>-----]<-.
It spreads * on the tape and checks if the second branch went past the first.
(.*),\1$
\*+
If the right-hand-side has an equal or less number of *'s, then those *'s are removed from both sides, along with the ,.
Then the number of runs of *'s are counted.
Returns true/false instead of 1/0
>Ô?2:U<Ô
>Ô?2:U<Ô :Implicit input of string U
> :Greater than
Ô : U reversed
? :If true
2 : Literal 2
: :Else
U<Ô : U less than U reversed?
5 bytes just to handle the I/O requirements :\
q, mÊrÎu3
q, mÊrÎu3 :Implicit input of string
q, :Split on ","
m :Map
Ê : Length
r :Reduce by
Î : Sign of difference
u3 :Positive modulo 3
If we could take a space delimited string as input then -2 bytes:
¸mÊrÎu3
If we could take an array as input then -1 more byte:
mÊrÎu3
And, if we could use any 3 distinct values for the output then -2 more bytes:
mÊrÎ
s->(Long.signum(s.indexOf(44)*2-s.length()+1)+3)%3
-24 bytes thanks to @OlivierGrégoire.
Explanation:
s->{ // Method with String parameter and long return-type
Math.signum( // Take the signum of:
s.indexOf(44) // The index of ',' (codepoint 44)
*2 // multiplied by 2
-s.length() // Subtract the entire length of the input
+1 // And add 1
+3) // Then increase that result by 3
%3 // And take modulo-3 on it
Long.signum exists. It might be better than Math.signum so that there's not this trailing .0.
\$\endgroup\$
Jun 8, 2020 at 15:45
"," with 44 (which is the codepoint for the comma).
\$\endgroup\$
Jun 8, 2020 at 17:00
3|i.&','*@--:@<:@#
3|i.&','*@--:@<:@#
-:@<:@# halved (length-1) of list
(where , would be in a balanced list)
i.&',' position of the ,
*@- signum'd difference between both
3| mod 3
This inserts - and + between the bit mask of the string: **,* -> 1 1 0 1 -> 1 + (1 + (0 - 1))) to get the difference between both sides. Then both signum and mod 3 like other solutions.
3|[:*'*'-`+@.[/@:=]
3|[:*'*'-`+@.[/@:=]
'*' =] '***,*' -> 1 1 1 0 1
-`+@.[ a function that chooses - or + based on the left argument
/@: puts this function inbetween: 1+(1+(1+(0-1))) = 2
[:* signum: 2 -> 1
3| mod 3
2>1~:1+v
p^_"$"2 0
.@^-","_$2\-
After initially pushing 2 to the stack, we push 1 for every * we encounter. After finding the ,, we start popping them instead. When we run out of input we subtract the top of the stack from 2, resulting in the correct output values.
=MOD(3-SIGN(1+LEN(A1)-2*FIND(",",A1)),3)
Finds the difference between Total Length + 1 and twice the position of the comma (Negative: Left; Zero: Tie; Positive: Right), use SIGN to convert these into -1, 0 and 1. Then subtract this from 3 to give 4/0/2, and take the Modulo Base 3 (1, 0, 2)
Old version: 44 Bytes
=MID(102,2+SIGN(1+LEN(A1)-2*FIND(",",A1)),1)
Finds the difference between Total Length + 1 and twice the position of the comma (Negative: Left; Zero: Tie; Positive: Right), use SIGN to convert these into -1, 0 and 1, add 2 (1, 2, 3), and then use MID to take the first, second or third digit from 102, respectively.
(Using MID saved 3 bytes over using CHOOSE)
I also experimented with a more maths-based approach (Multiply the Sign by 1.5, round it in the Positive direction with CEILING, then take the Absolute value), but that was 51 bytes instead.
-4 bytes thanks to math junkie
A third approach to this in python.
def f(x):a,b=x.split(',');return(1,0,2)[((a<b)-(a>b))+1]
This is a complete program and can be compiled with gcc. Input is the first command line argument and output is the exit status.
main(u,v)int**v;{u=strlen(*++v)-strspn(*v,"*")*2;exit(u>1?2:u!=1);}
x;f(char*z){char*Z,*W;for(Z=z;44-*Z++;);for(W=Z;*W++;)Z--;x=!!x*((x=z-Z+1)<0?1:2);}
f(z,Z)long z,Z;{Z-=strlen(Z=index(z,44))+z-1;z=Z<0?2:!!Z;}
=IF(LEN(A1)+1=2*FIND(",",A1),0,IF(LEN(A1)<2*FIND(",",A1),1,2))
-1 byte thanks to Dominic van Essen -1 byre thanks to Chronocidal
>=: =IF(LEN(A1)+1=2*FIND(",",A1),0,IF(LEN(A1)>=2*FIND(",",A1),2,1))
\$\endgroup\$
Jun 8, 2020 at 15:48
>= to <, and swapping the 2 and the 1? (i.e. inverting the Logical Condition)
\$\endgroup\$
Jun 10, 2020 at 13:16
fn($s)=>(3+(($a=explode(',',$s))[0]<=>$a[1]))%3
This is the best I have so far.. Gosh, longer than Java and C :O
EDIT: saved 4 bytes using value of $v, now shorter than C!
EDIT2: thanks a lot to 640KB for finding the finely elegant way to have the right numbers! -4 bytes
Much shorter with only distinct values instead of fixed numbers requirement:
fn($s)=>($a=explode(',',$s))[0]<=>$a[1]
lambda x:y.index(max(y))+1if len({*(y:=x.split(","))})>1else 0
I know that there is a shorter python solution already posted, but cmp doesn't exist in python 3. And don't bother trying to use bitwise operators to increment the value... it ends up being the same byte count.
