I'm looking for a way to make a script to be more intuitive with Title Casing. What I'm looking for is a script that can recognize symbols (/, -, \, etc.) and typical acronyms (FEMA, CDC, [City]PD, etc.) and apply Title Casing as appropriate. What I currently have is:
SaveVar=%Clipboard%
Clipboard=
ClipWait, 0.5
Send ^c
ClipWait, 0.5
segment = %Clipboard%
; Replace text with text in title case
; Make words following "/" title case
StringUpper, segment, segment , T
; Process exceptions
segment := RegExReplace(segment, "\bA\b", "a")
segment := RegExReplace(segment, "\bAn\b", "an")
segment := RegExReplace(segment, "\bThe\b", "the")
segment := RegExReplace(segment, "\bTo\b", "to")
segment := RegExReplace(segment, "\bAt\b", "at")
segment := RegExReplace(segment, "\bIn\b", "in")
segment := RegExReplace(segment, "\bAs\b", "as")
segment := RegExReplace(segment, "\bAn\b", "an")
segment := RegExReplace(segment, "\bAnd\b", "and")
segment := RegExReplace(segment, "\bBut\b", "but")
segment := RegExReplace(segment, "\bOr\b", "or")
segment := RegExReplace(segment, "\bpdf\b", "PDF")
segment := RegExReplace(segment, "\bllc\b", "LLC")
segment := RegExReplace(segment, "\bdui\b", "DUI")
segment := RegExReplace(segment, "\bAmp\b", "amp")
segment := RegExReplace(segment, "\bPdf\b", "PDF")
segment := RegExReplace(segment, "\bBy\b", "by")
segment := RegExReplace(segment, "\bOf\b", "of")
segment := RegExReplace(segment, "\bFor\b", "for")
segment := RegExReplace(segment, "\b-up\b", "-Up")
; Make first letter uppercase
segment:=RegExReplace(segment, "(\w)(.+)","$U1$2")
; Replace segment text with modified contents of clipboard
Clipboard := segment
ClipWait, 0.5
Send ^v
Sleep 100
Clipboard=%SaveVar%
SaveVar=
return
The problem with this is it will lower case letters following symbols, and all except the first letter of acronyms. Is there a way to make exceptions for letters following symbols, or even apply spacing around the symbol before applying appropriate case?
Underneath the line:
segment:=RegExReplace(segment, "(\w)(.+)","$U1$2")
add the line:
segment:=RegExReplace(segment, "(\W)([a-z])","$1$U2")
\W is a symbol and if a lowercase letter follows it, i.e. [a-z] then return the captured symbol, together with the captured letter in uppercase.
Related
I have to script a pascal code that rations into calculation the frequency of a character's appearance in the code and displays it through the output mode
Input P2 changes:
Second Attempt at the coding phase
I tried revisioning the code.I added the output variable writeln('input array of characters'); & writeln('Number of Occurrences',k);, which should help me output how many times did the S character appear overall in the code, plus utilised the for & if commands to have the final values showcased based on the conditions, if the frequency is 1 then count in S, still getting errors, take a look at the Input P2 & Output P2
Input P1
function Count(t, s: String): Integer;
var
Offset, P: Integer;
begin
Result := 0;
Offset := 1;
P := PosEx(t, s, Offset);
while P > 0 do
begin
Inc(Result);
P := PosEx(t, s, P + 1);
end;
end;
Output P2
Target OS: Linux for x86-64
Compiling main.pas
main.pas(5,3) Error: Identifier not found "Result"
main.pas(7,8) Error: Identifier not found "PosEx"
main.pas(8,3) Error: Identifier not found "unsigned"
main.pas(8,12) Fatal: Syntax error, ";" expected but "identifier N" found
Fatal: Compilation aborted
Error: /usr/bin/ppcx64 returned an error exitcode
-------------------------------------------------------------------
Input P2
program p1
var S:string
i:integer
begin
writeln('input array of characters');
k:=O;
for i:=1 to length (S) do
if (S[i])='m') and (S[i+1]='a') then k:=k+1;
writeln('Number of Occurrences',k);
Readln;
end.
Output P2
Compiling main.pas
main.pas(2,1) Fatal: Syntax error, ";" expected but "VAR" found
Fatal: Compilation aborted
Error: /usr/bin/ppcx64 returned an error exitcode
The errors you see in the first block:
Identifier not found "Result"
Standard Pascal doesn't recognize the pseudovariable Result. In some Pascal implementations (like e.g. Delphi) it can be used to assign a value to the function result. The Pascal you are using needs to have the result of a function assigned to the name of the function. For example:
function Whatever(): integer;
begin
Whatever := 234;
end;
Identifier not found "PosEx"
Not all Pascal implementations include the PosEx() function. You need to use Pos() instead. But, the standard implementation of Pos() doesn't include the "search start position" that PosEx has. Therefore you need to ditch Pos() and do as you do in "Input P2", that is traverse the text character per character and count the occurances as you go.
Identifier not found "unsigned"
Seems you have removed that unknown identifier.
The error you see in the second block:
In Output P2 the error message should be clear. You are missing a semicolon where one is needed. Actually you are missing three of them.
You are also missing the line that reads user input: ReadLn(S);.
Finally, to calculate both upper and lower case characters you can use an extra string variable, say SU: string to which you assign SU := UpperCase(S) after reading user input, and then use that string to count the occurances.
I think this is more like what you want to do:
function Count(t, s: String): Integer;
var
Offset,Res, P: Integer;
begin
Res := 0
Offset := 1;
repeat
P := Pos(t, s, Offset);
if p>0 then
Inc(Res);
Offset := P+1
untl P = 0;
Count := Res;
end;
Now, if you don't have Pos, you can implement it:
Function Pos(const t,s:string; const Start:integer):Integer;
Var
LS, LT, {Length}
IxS, IxT, {Index)
R: Integer; {Result}
begin
R := 0;
{use only one of the two following lines of code}
{if your compiler has length}
LS := length(S); LT := Length(T);
{If it does not}
LS := Ord(s[0]); LT := Ord(T[0]);
if (LS <= LT) {if target is larger than search string, it's not there}
and (Start<=LT) and {same if starting position beyond size of S}
(Start+LT <-LS) then {same if search would go beyond size of S}
begin {Otherwise, start the search}
ixT := 1;
ixS := Start;
repeat
Inc(R); {or R:= R+1; if INC not available }
If (S[ixS] <> T[ixT]) then
R := 0 {they don't match, we're done}
else
begin {Move to next char}
Inc(ixS);
Inc(ixT);
end;
until (R=0) or (ixT>LT); {if search failed or end of target, done}
Pos := R;
end;
I created a map:
l := make(map[*A]string)
where A is:
type A struct{}
Then added key-values into it:
a1 := &A{}
a2 := &A{}
a3 := &A{}
l[a1] = "a1"
l[a2] = "a2"
l[a3] = "a3"
I expected to see all values ("a1", "a2", "a3") while doing range
for k, v := range l{
fmt.Println(k, v)
}
But I see only the last one.
Why that happens?
https://play.golang.org/p/GSdUWzExxLK
Because your struct has no fields, Go optimizes away all pointers to it to the same address, so you're using the same key every time. Give the struct a field (even if you never put a value in it) and you'll get your expected behavior.
Playground: https://play.golang.org/p/n-WUZ9wqpGJ
You can read more about empty structs (including this pointer behavior) on Dave Cheney's blog.
It's mentioned only briefly in the spec, under Sizes and Alignments, and is in fact the very last sentence in the spec:
A struct or array type has size zero if it contains no fields (or elements, respectively) that have a size greater than zero. Two distinct zero-size variables may have the same address in memory.
This is because A is an empty structure. As it cannot change go always assigns it the same memory address. If you add a field to A it will start working:
type A struct{a string}
func main() {
a1 := A{}
a2 := A{}
l := make(map[*A]string)
l[&a1] = "a1"
l[&a2] = "a2"
for i, v := range l{
i := i
fmt.Println(&i, v)
}
}
Prints:
0x40e138 a1
0x40e150 a2
https://play.golang.org/p/hYzU73kbVPV
Dave Cheney goes into more depth here:
https://dave.cheney.net/2014/03/25/the-empty-struct
Hi i was wondering if anyone can help me with the following procedure using maple
The protocol of the rsa decryption/encryption method is below and the question i am trying to attempt after that with my attempt below it, i will appreciate any help. Thanks
my current attempt is the following
rsa := proc (key::rsakey, msg::(list(rsascii)))
local ct, pe, pm, i;
pm := 26271227347;
pe := key[2];
ct := [];
for i to nops(msg) do ct := [op(ct), `mod`(message[i]^pe, pm)]
end do;
RETURN(ct)
end proc;
this was from using the maple website
You've been given n and e, and you'll need to find the corresponding d before you can decode. I don't understand why you were trying to use e to decode.
Your procedure contains at least one type, using message[i] instead of msg[i]. See also comments in the code below.
After finding d I get that the encoded integer 11393739244 decodes to the integer 87, which corresponds to the ASCII character "W" (not "wha" or "Wha" as you suggested).
I don't understand what you intend on doing about block size, and so I've had to guess. Below I show encoding/decoding done either A) a character at a time, or B) using three characters at once. I trust you realize that encoding one-character-at-a-time isn't a great idea. Also, in a duplicate post in another forum you wrote that you don't care about security against attack. (You also wrote there that this isn't homework, but here it looks like it more, IMO.)
If you had trouble writing and using your rsa procedure then you may find the various splitting/concetenating/padding operations tough also.
You wrote in a comment that when you tried to use your initial attempt at procedure rsa then, "it doesn't give anything back". If it returned as an unevaluated call then perhaps your attempt at creating the proc and assigning it didn't actually work. If you have trouble using Maple's default 2D Input mode in a Document then consider switching your preferences to 1D Maple Notation input in a Worksheet. Those are two Preferences for Maple's Standard Java GUI.
NB. I use Maple's numtheory[lambda] command to find "the smallest integer i such that for all g coprime to n, g^i is congruent to 1 modulo n". In recent Maple versions this is also avaliable as the command NumberThoery:-CarmichaelLambda. See also here.
restart;
# The procedure `rsa` below can be used to both encode or
# decode an integer.
#
# Conversion from/to ASCII is done separately, before/after.
rsa := proc(key::list(posint), msg::list(posint))
local ct, pe, pm, i;
pm := key[1];
pe := key[2];
## The original used `message` instead of `msg`, which was
## a careless typo. But iterated list concatenation like this
## is inefficient. Better to just use `seq`, as below.
## Also, use inert `&^` instead of `^` in the call to `mod`
## since the latter inefficiently computes the power
## explicitly (before taking the modulus).
#ct := [];
# for i to nops(msg) do ct := [op(ct), `mod`(msg[i] &^ pe, pm)]
#end do;
ct := map(u->`mod`(u &^ pe, pm), msg);
return ct;
end proc:
# You supplied (n,e) and you'll need to find d in order to decode.
n:=26271227347;
n := 26271227347
L := numtheory[lambda](n);
L := 13135445468
e:=11546465;
e := 11546465
evalb( e < L ); # a requirement
true
evalb( gcd(e, L) = 1); # a requirement
true
d := 1/e mod L;
d := 7567915453
# Now decode the number you supplied.
res := rsa([n,d],[11393739244]);
res := [87]
with(StringTools):
# So what ASCII character is that?
convert(res,bytes);
"W"
s := "Wha":
sb := map(convert,convert(s,bytes),string);
sb := ["87", "104", "97"]
sbn := map(parse,sb);
sbn := [87, 104, 97]
encoded := rsa([n,e],sbn);
encoded := [11393739244, 9911682959, 21087186892]
decoded := rsa([n,d],encoded);
decoded := [87, 104, 97]
pad := proc(str::string)
local r;
r := irem(length(str),3);
cat(seq("0",i=1..`if`(r=0,0,3-r)), str);
end proc:
map(pad, map(convert,decoded,string));
["087", "104", "097"]
cat(op(map(u->convert(map(parse,[LengthSplit(convert(u,string),3)]),
bytes), %)));
"Wha"
newsb := [cat(op(map(SubstituteAll,map(PadLeft,sb,3)," ","0")))];
newsb := ["087104097"]
newsbn := map(parse,newsb);
newsbn := [87104097]
encoded := rsa([n,e],newsbn);
encoded := [15987098394]
decoded := rsa([n,d],%);
decoded := [87104097]
map(pad, map(convert,decoded,string));
["087104097"]
cat(op(map(u->convert(map(parse,[LengthSplit(convert(u,string),3)]),
bytes), %)));
"Wha"
If I have a map m is there a better way of getting a slice of the values v than this?
package main
import (
"fmt"
)
func main() {
m := make(map[int]string)
m[1] = "a"
m[2] = "b"
m[3] = "c"
m[4] = "d"
// Can this be done better?
v := make([]string, len(m), len(m))
idx := 0
for _, value := range m {
v[idx] = value
idx++
}
fmt.Println(v)
}
Is there a built-in feature of a map? Is there a function in a Go package, or is this the only way to do this?
As an addition to jimt's post:
You may also use append rather than explicitly assigning the values to their indices:
m := make(map[int]string)
m[1] = "a"
m[2] = "b"
m[3] = "c"
m[4] = "d"
v := make([]string, 0, len(m))
for _, value := range m {
v = append(v, value)
}
Note that the length is zero (no elements present yet) but the capacity (allocated space) is initialized with the number of elements of m. This is done so append does not need to allocate memory each time the capacity of the slice v runs out.
You could also make the slice without the capacity value and let append allocate the memory for itself.
Unfortunately, no. There is no builtin way to do this.
As a side note, you can omit the capacity argument in your slice creation:
v := make([]string, len(m))
The capacity is implied to be the same as the length here.
Go 1.18
You can use maps.Values from the golang.org/x/exp package.
Values returns the values of the map m. The values will be in an indeterminate order.
func main() {
m := map[int]string{1: "a", 2: "b", 3: "c", 4: "d"}
v := maps.Values(m)
fmt.Println(v)
}
The package exp includes experimental code. The signatures may or may not change in the future, and may or may not be promoted to the standard library.
If you don't want to depend on an experimental package, you can easily implement it yourself. In fact, this code is a copy-paste from the exp package:
func Values[M ~map[K]V, K comparable, V any](m M) []V {
r := make([]V, 0, len(m))
for _, v := range m {
r = append(r, v)
}
return r
}
Not necessarily better, but the cleaner way to do this is by defining both the Slice LENGTH and CAPACITY like txs := make([]Tx, 0, len(txMap))
// Defines the Slice capacity to match the Map elements count
txs := make([]Tx, 0, len(txMap))
for _, tx := range txMap {
txs = append(txs, tx)
}
Full example:
package main
import (
"github.com/davecgh/go-spew/spew"
)
type Tx struct {
from string
to string
value uint64
}
func main() {
// Extra touch pre-defining the Map length to avoid reallocation
txMap := make(map[string]Tx, 3)
txMap["tx1"] = Tx{"andrej", "babayaga", 10}
txMap["tx2"] = Tx{"andrej", "babayaga", 20}
txMap["tx3"] = Tx{"andrej", "babayaga", 30}
txSlice := getTXsAsSlice(txMap)
spew.Dump(txSlice)
}
func getTXsAsSlice(txMap map[string]Tx) []Tx {
// Defines the Slice capacity to match the Map elements count
txs := make([]Tx, 0, len(txMap))
for _, tx := range txMap {
txs = append(txs, tx)
}
return txs
}
Simple solution but a lot of gotchas. Read this blog post for more details: https://web3.coach/golang-how-to-convert-map-to-slice-three-gotchas
As far as I'm currently aware, go doesn't have a way method for concatenation of strings/bytes in to a resulting string without making at least /two/ copies.
You currently have to grow a []byte since all string values are const, THEN you have to use the string builtin to have the language create a 'blessed' string object, which it will copy the buffer for since something somewhere could have a reference to the address backing the []byte.
If a []byte is suitable then you can gain a very slight lead over the bytes.Join function by making one allocation and doing the copy calls your self.
package main
import (
"fmt"
)
func main() {
m := make(map[int]string)
m[1] = "a" ; m[2] = "b" ; m[3] = "c" ; m[4] = "d"
ip := 0
/* If the elements of m are not all of fixed length you must use a method like this;
* in that case also consider:
* bytes.Join() and/or
* strings.Join()
* They are likely preferable for maintainability over small performance change.
for _, v := range m {
ip += len(v)
}
*/
ip = len(m) * 1 // length of elements in m
r := make([]byte, ip, ip)
ip = 0
for _, v := range m {
ip += copy(r[ip:], v)
}
// r (return value) is currently a []byte, it mostly differs from 'string'
// in that it can be grown and has a different default fmt method.
fmt.Printf("%s\n", r)
}
As of 1.18, this is the best way:
https://stackoverflow.com/a/71635953/130427
Pre 1.18
You can use this maps package:
go get https://github.com/drgrib/maps
Then all you have to call is
values := maps.GetValuesIntString(m)
It's type-safe for that common map combination. You can generate other type-safe functions for any other type of map using the mapper tool in the same package.
Full disclosure: I am the creator of this package. I created it because I found myself rewriting these functions for map repeatedly.
I've figured out how to display the repeating part of a repeating decimal using OverBar.
repeatingDecimal doesn't actually work as a repeating decimal. I'd like to make a variation of it that looks and behaves like a repeating decimal.
Question
How could I make a working repeating decimal representation (possibly using Interpretation[])?
Background
Please excuse me if I ramble. This is my first question and I wanted to be clear about what I have in mind.
The following will "draw" a repeating decimal.
repeatingDecimal[q2_] :=
Module[{a},
a[{{nr__Integer}, pt_}] :=
StringJoin[
Map[ToString,
If[pt > -1, Insert[{nr}, ".", pt + 1],
Join[{"."}, Table["0", {Abs[pt]}], {nr}]]]];
(* repeating only *)
a[{{{r__Integer}}, pt_}] :=
Row[{".", OverBar#StringJoin[Map[ToString, {r}]]}];
(* One or more non-repeating;
more than one repeating digit KEEP IN THIS ORDER!! *)
a[{{nr__, {r__}}, pt_}] :=
Row[{StringJoin[
Map[ToString,
If[pt > -1, Insert[{nr}, ".", pt + 1],
Join[{"."}, Table["0", {Abs[pt]}], {nr}]]]],
OverBar#StringJoin[Map[ToString, {r}]]}];
(* One or more non-repeating; one repeating digit *)
a[{{nr__, r_Integer}, pt_}] :=
Row[{StringJoin[Map[ToString, {nr}]], ".",
OverBar#StringJoin[Map[ToString, r]]}];
a[RealDigits[q2]]]
So
repeatingDecimal[7/31]
displays a repeating decimal properly (shown here as a picture so that the OverBar appears).
Looking under the hood, it's really just an imposter, an image of a repeating decimal ...
In[]:= repeatingDecimal[7/31]//FullForm
Out[]:= Row[List[".",OverBar["225806451612903"]]]
Of course, it doesn't behave like a number:
% + 24/31
I'd like the addition to yield: 1
Edit: A cleaned up version of repeatingDecimal
Leonid showed how to wrap Format around the routine and to supply up-values for adding and multiplying repeated decimals. Very helpful! It will take some time for me to be comfortable with up and down values.
What follows below is essentially the streamlined version of the code suggested by Mr.Wizard. I set the OverBar above each repeating digit to allow line-breaking. (A single OverBar above Row looks tidier but cannot break when the right screen-margin is reached.)
ClearAll[repeatingDecimal]
repeatingDecimal[n_Integer | n_Real] := n
Format[repeatingDecimal[q_Rational]] := Row # Flatten[
{IntegerPart#q, ".", RealDigits#FractionalPart#q} /.
{{nr___Integer, r_List: {}}, pt_} :> {Table[0, {-pt}], nr, OverBar /# r}
]
repeatingDecimal[q_] + x_ ^:= q + x
repeatingDecimal[q_] * x_ ^:= q * x
repeatingDecimal[q_] ^ x_ ^:= q ^ x
The table below shows some output from repeatingDecimal:
n1 = 1; n2 = 15; ClearAll[i, k, r];
TableForm[Table[repeatingDecimal[i/j], {i, n1, n2}, {j, n1, n2}],
TableHeadings -> {None, Table[("r")/k, {k, n1, n2}]}]
Checking the solution: Operating with repeating decimals
Let's now check the addition and multiplication of repeating decimals:
a = repeatingDecimal[7/31];
b = repeatingDecimal[24/31];
Print["a = ", a]
Print["b = ", b]
Print["a + b = ", a, " + ", b, " = ", a + b]
Print["7/31 \[Times] 24/31 = " , (7/31)* (24/31)]
Print["a\[Times]b = ", a*b, " = \n", repeatingDecimal[a*b]]
Print[N[168/961, 465]]
So addition and multiplication of repeating decimals work as desired. Power also appears to work properly.
Notice that 168/961 occupies 465 places to the right of the decimal point. After that, it starts to repeat. The results match those of N[168/961, 465], except for the OverBar, although line-breaks occur at different places. And, as is to be expected, this jibes with the following:
digits = RealDigits[168/961]
Length[digits[[1, 1]]]
Some effects of the Format[] wrapper on the behavior of N[] in summing repeated decimals
Mr.Wizard suggested that the Format wrapper is superfluous for the cases of Integers and Reals.
Let's consider how the following two additions
repeatingDecimal[7/31] + repeatingDecimal[24/31]
N#repeatingDecimal[7/31] + N#repeatingDecimal[24/31]
behave in four different cases:
Case 1: Results when Format wrapped around repeatingDecimals for Reals and Integers and up values are ON
As expected, the first addition yields an integer, the second a decimal.
Case 2: Results when Format NOT wrapped around repeatingDecimals for Reals and Integers but up values are ON
The Format wrapper around Reals and Integers doesn't affect the additions at hand.
Case 3: Results when Format wrapped around repeatingDecimals for Reals and Integers but up values are OFF
If upvalues are OFF, Format prevents addition from happening.
Case 4: Results when Format NOT wrapped around repeatingDecimals for Reals and Integers and up values are OFF
If upvalues are OFF and Format` NOT wrapped around repeatingDecimals for Reals and Integers , the second addition works as expected.
All the more reason to remove the Format wrapper for the case of reals and integers.
Anyone have any remarks about the different outcomes in Cases 3 and 4?
You shouldn't have given your repeatingDecimal DownVaues, but rather, FormatValues:
ClearAll[repeatingDecimal];
Format[repeatingDecimal[q2_]] :=
Module[{a},
a[{{nr__Integer}, pt_}] :=
StringJoin[
Map[ToString,
If[pt > -1, Insert[{nr}, ".", pt + 1],
Join[{"."}, Table["0", {Abs[pt]}], {nr}]]]];
(*repeating only*)
a[{{{r__Integer}}, pt_}] :=
Row[{".", OverBar#StringJoin[Map[ToString, {r}]]}];
(*One or more non-repeating;
more than one repeating digit KEEP IN THIS ORDER!!*)
a[{{nr__, {r__}}, pt_}] :=
Row[{StringJoin[
Map[ToString,
If[pt > -1, Insert[{nr}, ".", pt + 1],
Join[{"."}, Table["0", {Abs[pt]}], {nr}]]]],
OverBar#StringJoin[Map[ToString, {r}]]}];
(*One or more non-repeating;one repeating digit*)
a[{{nr__, r_Integer}, pt_}] :=
Row[{StringJoin[Map[ToString, {nr}]], ".",
OverBar#StringJoin[Map[ToString, r]]}];
a[RealDigits[q2]]]
Then, you can give it also UpValues, to integrate with common functions, for example:
repeatingDecimal /: Plus[left___, repeatingDecimal[q_], right___] := left + q + right;
repeatingDecimal /: Times[left___, repeatingDecimal[q_], right___] := left * q * right;
Then, for example,
In[146]:= repeatingDecimal[7/31]+24/31
Out[146]= 1
You can extend this approach to other common functions which you may want to work with repeatingDecimal.
Here is a possible refactoring of your updated code. I think it works this time (fingers crossed). If you do not need the color highlighting, you can leave off ~Style~ and the rest of that line.
ClearAll[repeatingDecimal];
Format[repeatingDecimal[n_Integer | n_Real]] := n;
Format[repeatingDecimal[q_Rational]] :=
Row[{IntegerPart#q, ".", RealDigits#FractionalPart#q}] /.
{{ nr___Integer, r_List:{} }, pt_} :>
Row#Join[
"0" ~Table~ {-pt},
{nr},
If[r === {}, {}, {OverBar#Row#r}]
] ~Style~ If[r === {}, Blue, If[{nr} === {}, Red, Gray]]
repeatingDecimal /:
(h : Plus | Times)[left___, repeatingDecimal[q_], right___] :=
h[left, q, right];
I will leave this older version here for reference, but I am now making edits to the Question community wiki.