Write a function or program that accepts one character (or a string of length 1) as input, and outputs the number of times that character occurs inside the code.
Input can be any character, printable or not. Output may be to standard out, or as a return value from a function. This is code golf, so the shortest submission in bytes wins. Good luck!
moOMooMOOmOoMoOMoOMoOMoOMoOMoOMoOMOOmoOMOoMOoMOoMOoMOoMOoMOoMOoMOoMOoMOomOoMOomoomoOMMMMOOMOomoomoOMoOMoOMoOMoOMoOMoOMoOMoOmOomooMMMMOOMOoMOoMMMmoOMoOMoOmoOMOomOomOoOOOmooMMMMOOmOoMoOMoOMoOMoOMOOmoOMOoMOoMOoMOoMOoMOoMOoMOomOoMOomoomoOMMMmoOMOomoOMoOmOomOoOOOmooMMMMOOMoOMoOMMMmoOOOOMoOMoOMoOmoOMOoMOomOomOoOOOmooMMMMOOmoOmoomoOMOOmoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOMoOmOoMOomoomoOOOM
I appreciated a lot the previous solution (504 bytes) because it's deducted step by step, if you are interested please take a look at that in the timeline...
Now I furnish the program with a more "sensible" structure that promises to be less expensive (in terms of total byte count) but finding just a working set of values isn't simple...
To find the best, brute force comes in.
The next sections refers to the 390 bytes answer since it's simpler to explain that and then tell what it's done to save 3 bytes.
\$L = \{M,O,o,m\}\$ is the set of used chars and \$n_1,\dots ,n_4\$ their count.
The program has a structure that allows to form the output number \$n_i\$ as
$$
\begin{align}
n_i = x_i\times cf+y_i
\end{align}
$$
Furthermore we don't need to form \$x_i\$ and \$y_i\$ every time from zero, we reach them using the partial sums of 2 sequences occurring in cells [2] and [3] respectively.
[0]: multiplier for [1] [1]: input-current_char [2]: x_i [3]: y_i
[1] = getchar()
if[1] { [1]-=77(M), [2]+=8, [3]+=0, cut[1] } paste[1] //checks for 'M' and prepares its count
if[1] { [1]-= 2(O), [2]+=2, [3]+=0, cut[1] } paste[1] //checks for 'O' and prepares its count
if[1] { [1]-=32(o), [2]-=1, [3]-=1, cut[1] } paste[1] //checks for 'o' and prepares its count
if[1] { [1]+= 2(m), [2]-=6, [3]-=2, cut[1] } paste[1] //checks for 'm' and prepares its count
if ![1] //input was one of the letters above
print [2]*13+[3]
else //input was something else
print [4] (0)
As long as the input doesn't match any letter in \$L\$, [1] stays ≠ 0 and [2] and [3] hold \$x_i\$ and \$y_i\$ of the last tested letter.
Otherwise, if [1] has become 0, those value are no longer updated and at the end they will form the related \$n_i\$.
(When the input isn't a letter in \$L\$, after the 4 tests [1] is still ≠ 0 so the flow enters a loop ([>]) that sabotages the placement of the head, thus prevents from printing \$n_4\$ (the number of o).)
I've first constructed the exoskeleton: the complete program without the info about its char count.
That is without \$cf\$(common factor) and the 2 sequences that form \$x_i\$ and \$y_i\$.
moo ] mOo < MOo - OOO * Moo .
MOO [ moO > MoO + MMM = oom o
>.
[ <+++++++[>-----------<-]> > ? > ? << =*]=
[ -- > ? > ? << =*]=
[ <++++[>--------<-]> > ? > ? << =*]=
[ ++ > ? > ? << =*]=
[>]
>[> ? <-]>o
Some of them can be negative but I know that in order to write them I'll spend \$len\$: the sum of their absolute value in MoOs and MOos (+ and -).
Thanks to this condition the comptutation is rather straightforward.
\$cf>0\qquad\qquad A=\{a_1,\ a_2,\ a_3,\ a_4,\ a_5,\ a_6,\ a_7,\ a_8\}\$
\$x_i=\sum_{j=1}^{i} a_j \qquad y_i=\sum_{j=5}^{4+i} a_j\$
\$n_i = x_i\times cf+y_i\$
\$len = cf + \sum_{j=1}^{8} |a_j|\$
$$ (*)\begin{cases} n_1=|M|+len\\ n_2=|O|+len\\ n_3=|o|+len\\ n_4=|m| \end{cases} $$
Given the letter count in the exoskeleton \$|M|=71,\ |O|=97,\ |o|=85,\ |m|=38\$
we can now search for \$cf\$ and \$A\$ that satisfies \$(*)\$ minimizing \$len\$.
cf = 13, A = [8, 2, -1, -6, 0, 0, 1, -2] is the best for that exoskeleton (\$len=33\$)
>.
[ <+++++++[>-----------<-]> > ++++++++ > << =*]=
[ -- > ++ > << =*]=
[ <++++[>--------<-]> > - > + << =*]=
[ ++ > ------ > -- << =*]=
[>]
>[>+++++++++++++<-]>o
As you can se when some \$a_i\$ is \$0\$ its relative pair of > < became non-functional. But obviously we can't take them off in retrospect.
Juggling with the exoskeleton I've found that there is one configuration slightly different that overall saves 3 bytes (1 instruction). What's different?
* is replaced with [-] that has the same effect (+2 instr.)* \$x_4\$ is detached from the partial sum: \$x_4=a_4\$ (+1 instr.)> < are saved because \$a_5=0\$ (-2 instr.)The letter count of this exoskeleton is \$|M|=73,\ |O|=98,\ |o|=86,\ |m|=37\$
cf = 13, A = [8, 2, -1, 3, 0, -1, 1, -2] is the best. (\$len=31\$) (-2 instr.)
y=>"3.>=includes(*)\\\"y3.>=includes(*)".includes(y)*3
A bit convoluted but I tried to avoid using f= that would violate the proper quine requirement. The code is written in the way that all characters occur exactly 3 times.
A function made of 19 distinct characters used twice each.
_=>_.match`[\\]chmt[-a.02:=>?^^-]`?2:0
The range going from [ to a allows us to match the backtick and the underscore, which are both already doubled in the code, without explicitly including them in the pattern.
This method comes with two minor drawbacks:
^, we need to insert it twice in the code as well although it's not part of the payload.-.Character set:
-.02:=>?[\]^_`achmt
y/+N"y/+N"
y/+N"y/+N"
"y/+N" String literal
+N Append the string `"`
/ Count occurrences of the input in that string
y Multiply by 2
(2*1#.=&'(2*1#.=&)+6*=&')+6*=&''''
single quote
quoted program adjustment
| /
vvvvvvvvvvvvvvvv _____/___
(2*1#.=&'(2*1#.=&)+6*=&')+6*=&''''
^^^^^^^^ ^^^^^^^^^^
\ /
regular program
^ is part of the "regular program".'2*1#.=&'...' - Two times 2* the sum of 1#. the total number of times the input char matches a char in "the quoted program". One for the actual program char, one for its quoted twin.+6*=&'''' - Plus six times +6* the 1/0-indicator of whether the input char is equal to a single quote =&''''. This is the hardcoded knowledge that there are 6 single quotes in the program.
".+#H".""+#H
Takes as input a code point. Those provided in the test are for each character in the program, as well as their immediate predecessors and successors.
".+#H".""+#H
".+#H" String literal ".+#H"
."" String literal "\"\""
+ Concatenate
# Count occurrences of the input
H Double
Constructs a string of half the program, permuted somehow. Counts occurrences there, then doubles.
-2 thanks to caird coinheringaahing (input is a character, not a string!)
“ḤṾċⱮ”Ḥċ
A monadic Link accepting a character that yields the count.
“ḤṾċ”ḤṾċ - Main Link: character, c
(A full program with a single character as input gives the main
Link a list of characters - i.e. S = ['c'])
“ḤṾċ” - list of characters = ['Ḥ', 'Ṿ', 'ċ']
Ḥ - double = ["ḤḤ", "ṾṾ", "ċċ"] (Python strings)
Ṿ - un-eval = ['“', 'Ḥ', 'Ḥ', 'Ṿ', 'Ṿ', 'ċ', 'ċ', '”']
ċ - count occurrences of c (in the un-eval-ed list)
- implicit print (a list with a single entry just prints that entry)
Ｉ⊗№⁺´”´””yＩ⊗№⁺´´yＳ”Ｓ
Try it online! Explanation:
´”´” Literal string `””`
⁺ Concatenated with
”yＩ⊗№⁺´´yＳ” Literal string `Ｉ⊗№⁺´´yＳ`
№ Ｓ Count matches of input character
⊗ Doubled
Ｉ Cast to string
Implicitly print
Charcoal has two ways of quoting non-ASCII characters, ´ (which quotes a single character) and ”y...” (which quotes anything except ”). Trying to do everything with ´ is awkward because it uses too many of them; the best I could do was 26 bytes.
Port of the Stax answer. ¢ is order-sensitive, which is fairly annoying here.
"„Js¢·"„""Js¢·
As for this... I wrote this myself.
„…J…¢s·'„'D''DJs¢·
„…J 2-char string. …, J
…¢s· 3-char string. ¢, s, ·
'„ 1-char string. „
'D 1-char string. D
'' 1-char string. '
D Copy this character.
J Join the stack.
s¢ Count occurances of the input in the string.
· Multiply the count by 2. (Perfectly makes the 0-count still 0.)
print 1;#!"$%&'()*+,-./023456789:<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghjklmoqsuvwxyz{|}~...
Replace the trailing ... with the 33 unprintable characters (ASCII 0 .. ASCII 31 + ASCII 127), with the newline at the end. (If anyone knows how to put unprintable characters in a textfield and have them show up here, I'm all ears).
3*sum(unlist(strsplit(c('"',"#'''((()))*,,3=acilmnprsssttu"),''))==scan(,''))##()*,3amprst
Edit1: thanks to math junkie for pointing-out a horrible bug in the original version (the \ character): hence the temporary increase and subsequent decrease in byte-length, as successive patches were added in panic..
Edit2: -4 bytes: Copying the entire program into the 'look-up' string seemed wasteful (94 bytes), so instead added extra characters so that every character was present an even-number of times, and now just include half the program (character-wise) in the look-up string
"\x5c" for a backslash `\`. Would require a significant rework, no doubt.
\$\endgroup\$
∈"∈∈\\\"∧33||"∧3|∧
Brachylog doesn't really have any good way to get quotes without escaping them in a string literal (or using the Ṭ constant, which came out longer when I tried it), so the approach I came to is to simply triple down on everything else.
(I don't know why the testing header runs out of stack after it's done every test case; I'd think it's something to do with the unbound variable output for 0 but it works fine on individual inputs... so long as an unbound variable is indeed an acceptable way to give 0. If it's not, +3 bytes)
x="(x+2*chr(34)+'x=;f=eval(x)').count";f=eval(x)
Idea: Store code in string. The stored code returns function that counts characters in the string within which it is contained. Evaluate the string to get the function. Special care for characters wrapping the string.
eval I, 48 bytes lambda c:3*(c in" \\\"(())**33::abbcddiillmmnn")
eval II, 124 bytesAnd a more creative, but much longer solution:
lambda c:[0o3623>(ord(c)-76)**2>195,' !!""##$$%%&&++,-..//4457889:;;==ZZ\\^^__``beeffgghhiijjkklmnnppqqrssttuuvvwwxx'][0]<<1
Idea: Ensure all characters that satisfy a certain equation (195 < (c-76)² < 1939) appear exactly twice in the code, and return 2 for those characters (0 for all others). Maybe someone can think of a better compression for the long string, but remember expressing it may only use the same character twice.
D#hs"D#hs"
D Twice
# the number of occurrences of the input in
"D#hs" "D#hs",
s quoted,
h without the second quote.
For the same number of bytes:
#S+s"#S+s"
Somewhat boring adaptation of the standard S+s"S+s+ quine.
T`Tan[-a\]\n^0__-`2
[^2]
0
I got the idea to use [-a from @Arnauld's JavaScript answer.
Explanation
T`Tan[-a\]\n^0__-`2
Transliterate each of the following characters into a 2:
The letters T, a, and n
The range [-a which also includes \, ], ^, _, and `
Literal ] and literal newline
The characters ^, 0, _, and -
[^2]
0
Replace any character that is not a 2 with a 0
-plF, 49 bytes$_=q($_=grep/\Q@F/,qq(\$_=q($_);eval)=~/./g);eval
Pretty much the standard quine with some minor changes.
The program itself is stored in $_ which is evaled (eval - along with most other functions - works on $_ by default if no argument is specified. When the program is evaluated, $_ is set to the number of matches (~~grep) against the input char /\Q@F/, which is interpolated at runtime and necessitates \Q to escape any special chars, against the list of chars resulting from the template string $_=q(...);eval with the actual program interpolated in the innermost %_, which is obtained with =~/./g (this returns a list of all the chars that matches the regex, . being match-all).
1
Counts the number of 1s in the input, so the output is always 1 or 0.
Inspired by this answer on a related question.
-nl, p~/[,-2\[-\]p~,..011?:]/?2:0
Derived from my answer to a related challenge. Each of the 14 distinct characters in the code appears twice. The input is tested against a regexp. The outer [] is a character class containing literal characters plus two character ranges: ,-2 is equivalent to the literal characters ,-./012 and \[-\] is equivalent to the literal characters [\]. The code prints 2 if the regexp matches the input character; 0 is printed otherwise.
n[4467]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,1,0,0,3,3,0,0,126,0,0,0,92,15,17,2,2,2,2,2,0,1,0,2,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,1,2,0,0,0,2,0,1,1,1,1,1,1,2,0,0,0,1,5,0,1,0,2,0,2,0,0,0,0,0,0,2,0,2};main(){printf("%d\n",n[getchar()]);}
I'm not sure this counts, and if so deemed, I'll make it non-competing (or delete it if you guys think it's too egregious). The reasons why have to do with the Turing Machine Code interpreter I'm using. This affects the space character ( ), asterisk (*), and semi-colon(;).
Space character
Basically it internally converts space characters into underscores '_'. Also, it interprets the lack of any character as a space character, and therefore interprets that as an underscore. Not only this, but it also interprets an actual underscore '_' as an underscore (or space, or lack of a character). Since the input is strictly limited to the text box on the web page, this means there is significant ambiguity as to how to count a space character. So that character will not work with this code. Any attempts at trying to fudge something here could easily and reasonably be discounted as wrong by atleast 3 different valid interpretations that I can come up with off the top of my head.
Asterisk
This character is set aside for a few special uses, depending on where in the code it's used. Most relevantly for this challenge, the asterisk - when used as an input check - acts as a special catch-all character. So any attempt at trying to catch this as input, catches anything and everything, including the aforementioned space character. It does so without any ability to discern an actual asterisk from the infinite possibilities. So that character will not work with this code.
Semicolon
Lastly, the semicolon is a very strict line comment. You put that anywhere in that line of code, and that's it. Everything after it (inclusive) on that line is interpreted as a comment, and is ignored. As a result of this, this Turing Machine interpretor will never be able to 'read' the semicolon character ';'. So that character will not work with this code.
0 0 1 r 0
0 _ 2 * 2
0 r 7 * r
0 7 3 * r
0 2 7 * 2
0 3 5 * r
0 1 2 * r
0 5 3 * r
0 * 0 * 2;3325_
I'm deeply suspicious that there is a two or three line solution to this. I'll probably play around with this for a bit some more. Having to use a comment to pad the numbers really sets off a flag in my head that this code could accomplish this task far more efficiently.
[S S S N
_Push_0][S N
S _Duplicate_0][S N
S _Duplicate_0][T N
T S _Read_STDIN_as_character][T T T _Retrieve_input][S N
S _Duplicate][S S S T S S S S S N
_Push_32][T S S T _Subtract][N
T S S N
_If_0_Jump_to_Label_SPACE][S N
S _Duplicate][S S S T S S T N
_Push_9][T S S T _Subtract][N
T S T N
_If_0_Jump_to_Label_TAB][S S S T S T S N
_Push_10][T S S T _Subtract][N
T S S T N
_If_0_Jump_to_Label_NEWLINE][N
S N
N
_Jump_to_Label_PRINT][N
S S S N
_Create_Label_SPACE][S S S T S S T S T T N
_Push_75][N
S N
N
_Jump_to_Label_PRINT][N
S S T N
_Create_Label_TAB][S S S T S S S S T N
_Push_33][N
S N
N
_Jump_to_Label_PRINT][N
S S S T N
_Create_Label_NEWLINE][S S S T S S T S S N
_Push_36][N
S S N
_Create_Label_PRINT][T N
S T _Print_as_integer_to_STDOUT]
Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Character c = STDIN as character
If(c == ' '):
Print 75 to STDOUT
Else-if(c == '\t'):
Print 33 to STDOUT
Else-if(c == '\n'):
Print 36 to STDOUT
Else:
Print 0 to STDOUT
This sounds pretty straight-forward, but it was reasonably tricky to get the correct numbers. Pushing a number in Whitespace is done as follows:
S: Enable Stack ManipulationS: Push numberS/T: Positive/negative respectivelyT/S followed by a single N: Decimal as binary, where T is 1 and S is 0So, after I created the template of my program, the amount of newlines were fixed and I could simply print 36 in that case.
But the amount of spaces and tabs are variable. If I correct the count-output of the amount of spaces, the tabs would be incorrect, and vice-versa. This required some tweaking, which I eventually did without wasting any bytes by using a Label ST for the Label_NEWLINE. Usually I create Labels in the following order, based on the amount of times it's used: (empty label); S; T; SS; ST; TS; TT; SSS; etc. In this case, I've skipped the SS and used ST instead, allowing me to print 75 and 33 with the binary pushes of TSSTSTT and TSSSST for the counts of spaces and tabs respectively.
`I$O`I$O
Back then, there was no quine cheese. Now there is.
`I$O`I$O
`I$O` # The string "I$O"
I # surrounded in backticks and appended to itself
$O # Get the count of the input in that.
