[Question]
  [
[Suzhou numerals](https://en.wikipedia.org/wiki/Suzhou_numerals) (蘇州碼子; also 花碼) are Chinese decimal numerals:
```
0 〇
1 〡 一
2 〢 二
3 〣 三
4 〤
5 〥
6 〦
7 〧
8 〨
9 〩
```
They pretty much work like Arabic numerals, except that when there are consecutive digits belonging to the set `{1, 2, 3}`, the digits alternate between vertical stroke notation `{〡,〢,〣}` and horizontal stroke notation `{一,二,三}` to avoid ambiguity. The first digit of such a consecutive group is always written with vertical stroke notation.
The task is to convert a positive integer into Suzhou numerals.
## Test cases
```
1          〡
11         〡一
25         〢〥
50         〥〇
99         〩〩
111        〡一〡
511        〥〡一
2018       〢〇〡〨
123321     〡二〣三〢一
1234321    〡二〣〤〣二〡
9876543210 〩〨〧〦〥〤〣二〡〇
```
**Shortest code in bytes wins.**
  
[Answer]
# [R](https://www.r-project.org/), 138 bytes
I'll bet there's an easier way to do this. Use `gsub` to get the alternating numeric positions.
```
function(x,r=-48+~x)Reduce(paste0,ifelse(58<~gsub("[123]{2}","0a",x),"123"["一二三",r],'0-9'["〇〡-〩",r]))
"~"=utf8ToInt
"["=chartr
```
[Try it online!](https://tio.run/##XZDNaoNAFIX3PkW5Xah0BH9iqxAfoNvSnWRh7dgGiik6glAqsyuFvER/bJM3CHmd8T3snUnQ2GEWw3fPvefcKfpsbvVZladsucqNmhSRNQsumtq8ofdVSo3npGTUJsuMPpXU8IN581BWdwbEjustXtxXIGAnQGqTABKIodvxbr/udu9AigXRbSvUYxD8TfAPS/CtpKapQQNRxbLgdnWdMw3bovQxKVjRZ4bu6Ob52XCwT5NwQhGij@SuP@WfgreS@/aUtxhB8jCc8i3ew/xTg8P8o7X/r9SeuNtOMNaUu1xU8I2a6XqeO/TKrv1a8C/8G1QeJ6BmNooGjeDfUinfKkMYXF36UqjWUrE3gv8K/qPyjGIM0P8B "R – Try It Online")
[Answer]
# JavaScript, 81 bytes
```
s=>s.replace(/./g,c=>(p=14>>c&!p)|c>3?eval(`"\\u302${c}"`):'〇一二三'[c],p=0)
```
[Try it online!](https://tio.run/##dZDdTsIwGIbPvYrZGGkT2LqNCTNpvRAxYamFaBbWMOBETXpGTLgJf6ZwB4Tb6e5jdv4w0mLzHfTgeb8873efLJKcTe/ErDPJbnk1IlVOaO5OuUgTxqHneuM2IxQK4ncpZeenAj0yGl7xRZLCIRgM5iEOzh7YExiiy5aSy3Iry92q3D63rtlNWxCMKpZN8izlbpqN4QgCHzh/DyHH8xwlX05MpoH2jN5sYkFkYa9KFiYWYQsrtKqJxbGFbfTYbnu5Q7cjLSKbLP4pgv0@sIosNazk2hIIwjD42dwI7FZKvumz6@CR/TrS/c0YESXf62D9t/zjfu8iqnMYHBxkreSnkh/fXZqstq2@AA "JavaScript (Node.js) – Try It Online")
Using `14>>c` saves 3 bytes. Thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld).
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 46 bytes
```
/[1-3]{2}|./_T`d`〇〡-〩`^.
T`123`一二三
```
[Try it online!](https://tio.run/##K0otycxLNPz/Xz/aUNc4ttqotkZPPz4kISXhcUP744aFuo8bVibE6XGFJBgaGSc82dHwZFfPkx2d//8bchkachmZcpkacFlaAtmGXKYgAQNDCy6gSmMjQxBlAqItLczNTEEsAwA "Retina – Try It Online") Link includes test cases. Explanation:
```
/[1-3]{2}|./
```
Match either two digits 1-3 or any other digit.
```
_T`d`〇〡-〩`^.
```
Replace the first character of each match with its Suzhou.
```
T`123`一二三
```
Replace any remaining digits with horizontal Suzhou.
51 bytes in [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d):
```
M!`[1-3]{2}|.
mT`d`〇〡-〩`^.
T`¶123`_一二三
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w31cxIdpQ1zi22qi2Ro8rNyQhJeFxQ/vjhoW6jxtWJsTpcYUkHNpmaGScEP9kR8OTXT1PdnT@/2/IZWjIZWTKZWrAZWkJZBtymYIEDAwtuIBKjY0MQZQJiLa0MDczBbEMAA "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
M!`[1-3]{2}|.
```
Split the input into individual digits or pairs of digits if they are both 1-3.
```
mT`d`〇〡-〩`^.
```
Replace the first character of each line with its Suzhou.
```
T`¶123`_一二三
```
Join the lines back together and replace any remaining digits with horizontal Suzhou.
[Answer]
# [Perl 5](https://www.perl.org/) `-pl -Mutf8`, ~~53~~ 46 bytes
*-7 bytes thanks to Grimy*
```
s/[123]{2}|./OS&$&/ge;y//〇〡-〰一二三/c
```
[Try it online!](https://tio.run/##K0gtyjH9/79YP9rQyDi22qi2Rk/fP1hNRU0/PdW6Ul//cUP744aFuo8bNjzZ0fBkV8@THZ36yf//G3IZGnIZmXKZGnBZWgLZhlymIAEDQwsuoDnGRoYgygREW1qYm5mCWAb/8gtKMvPziv/r5hT813X@r@tbWpJmAQA "Perl 5 – Try It Online")
### Explanation
```
# Binary AND two consecutive digits 1-3 (ASCII 0x31-0x33)
# or any other single digit (ASCII 0x30-0x39) with string "OS"
# (ASCII 0x4F 0x53). This converts the first digit to 0x00-0x09
# and the second digit, if present, to 0x11-0x13.
s/[123]{2}|./OS&$&/ge;
# Translate empty complemented searchlist (0x00-0x13) to
# respective Unicode characters.
y//〇〡-〰一二三/c
```
[Answer]
# [Java (JDK)](http://jdk.java.net/), 120 bytes
```
s->{for(int i=0,p=0,c;i<s.length;)s[i]+=(p>0&p<4&(c=s[i++]-48)>0&c<4)?"A䷏乚䷖".charAt(c+(p=0)):(p=c)<1?12247:12272;}
```
[Try it online!](https://tio.run/##VVDLbsIwELzzFatIIFsJVpImBfIAIc49cUQcXJOAaXCi2KFCiG/orYf@COr/8B@pA5THYb2z493RaNZ0S7vrxUfNN0VeKljrmVSKZyStBFM8F2SSC1ltkjJssYxKCW@UC9i3AIrqPeMMpKJKt23OF7DRf2iqSi6WsznQcinxeRXgXyViK1rO5kNI41p2h/s0LxEXCnhsW4UuFvJIkiwRS7UKsZzxuRmjYmh3isjrIBZrxjTnXa@PNcciD4@M8en4dfr9OR2/DdKojxViJtJiGAe6MRw5I8d1vV6g354bHurwbOnmUyVSSYivTgEMx7Bu8AG7/h379h0PBo/7Dwf@07Xt9B/23JcX13mavSdi0O@9@g1lG2fqcDHd5HUxfrYdXMzjm/dLvCDjhicqnzSBlCXdIRxeV1JCGUsKheSNmu6kSjYkrxQptLZKkdF2bBlAW7aFYTValkg@r5Hpw@vlodXUof4D "Java (JDK) – Try It Online")
## Credits
* -3 bytes thanks to [Kevin Cruijssen](https://codegolf.stackexchange.com/users/52210/kevin-cruijssen)
[Answer]
# JavaScript (ES6), ~~95 89~~ 88 bytes
*Saved 6 bytes thanks to @ShieruAsakoto*
Takes input as a string.
```
s=>s.replace(i=/./g,c=>'三二一〇〡〢〣〤〥〦〧〨〩'[i=112>>i&c<4?3-c:+c+3])
```
[Try it online!](https://tio.run/##dZFPboJAFIf3noKwqBArf8VK06EHaVyQEQ2GiJGm67czTbxEa7F4A@N1HvfAV6hiZnQyi1l8v5fvN28efoQZX8XL9/4inUTVlFUZCzJjFS2TkEdazEzDnD1yFnTLw2d53JQHQFgjfCF8I2wRfhByhB3CL0KBsO@@xcy2nSCIH/jL4NXt8@ce77ljveLpIkuTyEjSmTbVVFtVzkfXFdNUaGhHZFrowpCBiDmehJFcLmKeJWGkvhYx35ewPV3Z7SJ37XajhSeT@Z0ilj1SpSLNdxeSgOO6TjO5FThuaCu0KgremE@RwX9GiNSL3NZvyd8fPQ29v5ylXn1IUa98V3dps2RbnQA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 102 bytes
```
f=0
for i in input():f=i in'123'and 9-f;print(end='〇一二三〤〥〦〧〨〩〡〢〣'[int(i)+f])
```
[Try it online!](https://tio.run/##K6gsycjPM/7/P83WgCstv0ghUyEzD4gKSks0NK3SbEFcdUMjY/XEvBQFS90064KizLwSjdS8FFv1xw3tT3Y0PNnV82RH5@OGJY8blj5uWPa4YfnjhhWPG1Y@blj4uGHR44bF6tEgHZma2mmxmv//W1qYm5maGBsZGgAA "Python 3 – Try It Online")
[mypetlion](https://codegolf.stackexchange.com/users/65255/mypetlion) reminded me of a trivial golf. -4 bytes.
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), ~~181~~ 165 bytes
All octal escapes can be replaced by the equivalent single-byte characters (and are counted as one byte each), but used for readability and because otherwise it breaks TIO and SE with invalid UTF-8.
```
import StdEnv
u=map\c={'\343','\200',c}
?s=((!!)["〇":s++u['\244\245\246\247\250']])o digitToInt
$[]=[]
$[h:t]=[?(u['\241\242\243'])h:if(h-'1'<'\003')f$t]
f[]=[]
f[h:t]=[?["一","二","三"]h: $t]
```
[Try it online!](https://tio.run/##NY@/asMwEId3P4UiDGcTB/wvLZiILOkQ6FBIN1mDsKNYYEkhlgulFLKVQh8o9HWa56iiYjp8d7/j7huu6fdcO2Xasd8jxaV2Uh3NyaKdbR/0SzASxY91Q96gLsoCEqjzNIWkeQ/WA4mi2Sym@Of8gathPh@p35alZ@m589zX@TIFxmKDWnmQ9tlstQ1CyghlvnWV9WkdTWLmyT0FsLirpIi6BWSwgjpNC4hFaFkgJlP8mxRfL2ec4Ov311@9fGLWVchfup3l/gmCQkQhyzJg7rcRPT8MbrF9dJtXzZVspuGp51aYk7oB "Clean – Try It Online")
An encoding-unaware compiler is both a blessing and a curse.
[Answer]
# [Red](http://www.red-lang.org), 198 171 bytes
```
func[n][s: charset"〡〢〣"forall n[n/1: either n/1 >#"0"[to-char 12272 + n/1][#"〇"]]parse
n[any[[s change copy t s(pick"一二三"do(to-char t)- 12320)fail]| skip]]n]
```
[Try it online!](https://tio.run/##VYwxTsMwFIb3nOLpdWmFKmyHtE0GDsFqeYgSm1qNHMs2QyWGbAiJSwCXqLhOco8QDwhn@///ve9zsp2fZMtFpqpZvZiGG8F9Bc25dl4GHIfPcfgah29Uvau7Dgw397QCqcNZOlgyPG6QIA/9PjJAGTsyuIsXwTcL/4ZC2CjLDK/NlXMf5eZZQtPbKwTwW6ubC063Yfr5mG7v2PbbP1vY7RdjzshO1boTr@Av2gphxGydNgEUIMXsP6eFFUkpSFLKcsWkULFWEHpKX1meM7oeHtZLeToeirgRnH8B "Red – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 38 bytes
```
9Rż“øƓ“œ%“øƈ’;-25+⁽-EỌœị@DżD<4«Ɗ‘×¥\ƊƊ
```
[Try it online!](https://tio.run/##y0rNyan8/98y6OieRw1zDu84NhlIHZ2sCuF0PGqYaa1rZKr9qHGvruvD3T1HJz/c3e3gcnSPi43JodXHuh41zDg8/dDSmGNdx7r@A42xMDczNTE2MjQAAA "Jelly – Try It Online")
[Answer]
# C, 131 bytes
```
f(char*n){char*s="〇〡〢〣〤〥〦〧〨〩一二三",i=0,f=0,c,d;do{c=n[i++]-48;d=n[i]-48;printf("%.3s",s+c*3+f);f=c*d&&(c|d)<4&&!f?27:0;}while(n[i]);}
```
[Try it online!](https://tio.run/##PU5LasMwEN3rFKmgRrKdIvmT2FVNDxKyCHKUGFI3RClduIbZlUIv0X97g9DryPdwJTfkwfA@8wZGjldS9r0icr3Y@TVtBtYFNvBo4MXAq4E3A@8GPgx8Gvgy8G3gpztA9/vcHZ5wWBUsVHZkWIrytpFFPauCYD5OMlE6Pajtrqr3iuDzi1jjUAfSjwNFhSqkX3oekQ8lvUo870xdR9NLJtr7dbVZEndNRdvfLKqa0AaNLNx/Iz2bJHMx@P/marnXRNNjx0FZK05ue2f3GB@TFrU9R5yjKEUpQ3luNUepCxjPEI/iOOKOEsd5Np2kTrE/ "C (gcc) – Try It Online")
Explanation:
First of all - I'm using char for all variables to make it short.
Array `s` holds all needed Suzhou characters.
The rest is pretty much iterating over the provided number, which is expressed as a string.
When writing to the terminal, I'm using the input number value (so the character - 48 in ASCII), multiplied by 3, because all these characters are 3 bytes long in UTF-8.
The 'string' being printed is always 3 bytes long - so one real character. 
Variables `c` and `d` are just 'shortcuts' to current and next input character(number).
Variable `f` holds 0 or 27 - it says if the next 1/2/3 character should be shifted to alternative one - 27 is the offset between regular and alternative character in the array.
`f=c*d&&(c|d)<4&&!f?27:0` - write 27 to f if c\*d != 0 and if they are both < 4 and if f isn't 0, otherwise write 0.
Could be rewritten as:
```
if( c && d && c < 4 && d < 4 && f == 0)
f = 27
else
f = 0
```
Maybe there are some bytes to shave off, but I'm no longer able to find anything obvious.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 35 bytes
```
9Ḷ;-26ż“/Ẉ8‘+⁽ȷc¤ṃ@ɓD_2ỊŒgÄFị"+⁽-FỌ
```
[Try it online!](https://tio.run/##y0rNyan8/9/y4Y5t1rpGZkf3PGqYo/9wV4fFo4YZ2o8a957YnnxoycOdzQ4nJ7vEGz3c3XV0UvrhFreHu7uVQNK6QFbP/4c7Nikc2qpwdI9CmMLh9kdNaxRUFNz//zdUMDRUMDJVMDVQsLQEsg0VTEECBoYWCoZGxsZGhiDKBERbWpibmYJYBgA "Jelly – Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg) `-p`, ~~85~~ 61 bytes
*-13 bytes thanks to Jo King*
```
s:g[(1|2|3)<((1|2|3)]=chr $/+57;tr/0..</〇〡..〩一二三/
```
[Try it online!](https://tio.run/##K0gtyjH7/7/YKj1aw7DGqMZY00YDyoi1Tc4oUlDR1zY1ty4p0jfQ07PRf9zQ/rhhoZ7e44aVT3Y0PNnV82RHp/7//4ZchoZcRqZcpgZclpZAtiGXKUjAwNCCy9DI2NjIEESZgGhLC3MzUxDL4F9@QUlmfl7xf90CAA "Perl 6 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-p`, 71 bytes
```
$_=gsub(/[1-3]\K[1-3]/){|x|(x.ord+9).chr}.tr"0-<","〇〡-〩一二三"
```
[Try it online!](https://tio.run/##KypNqvz/XyXeNr24NElDP9pQ1zg2xhtM6WtW11TUaFTo5RelaFtq6iVnFNXqlRQpGejaKOkoPW5of9ywUPdxw8onOxqe7Op5sqNT6f9/Qy5DQy4jUy5TAy5LSyDbkMsUJGBgaMFlaGRsbGQIokxAtKWFuZkpiGXwL7@gJDM/r/i/bgEA "Ruby – Try It Online")
[Answer]
# [K (ngn/k)](https://gitlab.com/n9n/k), 67 bytes
```
{,/(0N 3#"〇一二三〤〥〦〧〨〩〡〢〣")x+9*<\x&x<4}@10\
```
[Try it online!](https://tio.run/##XVFvboIwHP3OKRq2LLp/tCCbgB92gl1ATSCbOKLSBbqJMS79ZpZ4CXU4vIHxOuUerBSJsH5p8/r63u@9ju78oZ9lrjm/VRrwGWgXMqPL9EDT4yo9fDP6w2jM6I7RX0YTRveMrhndMLqVm9GNcd3pRVdRp7V4QrCX2dB0AVK1lg6AAkJn8j4eAM//xC8O8bB/DzgBTAOPDEJAMAjJK/4gYOqRt3x3cTBxCPH8oSQpnEJCiZjzy@7sK@CykWXjkdWwXccbW5E1s4JmfyGRLgLlsvjka7mfY6iG8TQCVvUqzDPEAtZhFeZhlwI2jCrMc@9P2uifdumq127iqjFE7ZrxUrSYFIKqpqnoLHhc8XJF9ZvyfV5pwalQxNdsxbnwN9qPD3rOg6eBE/FpOzHLmSvyZX8 "K (ngn/k) – Try It Online")
`10\` get list of decimal digits
`{` `}@` apply the following function
`x&x<4` boolean (0/1) list of where the argument is less than 4 and non-zero
`<\` scan with less-than. this turns runs of consecutive 1s into alternating 1s and 0s
`x+9*` multiply by 9 and add `x`
juxtaposition is indexing, so use this as indices in...
`0N 3#"〇一二三〤〥〦〧〨〩〡〢〣"` the given string, split into a list of 3-byte strings. k is not unicode aware, so it sees only bytes
`,/` concatenate
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 117 bytes
```
FromCharacterCode[12320+(IntegerDigits@#/. 0->-25//.MapIndexed[{a___,c=#2[[1]],c,b___}->{a,c,#,b}&,{0,140,9}+7648])]&
```
[Try it online!](https://tio.run/##FY5BC4IwGIb/SiBE0afbN13pwQiKwEPQfQyZc6UHNdYOgey32zw9Dw/v4R2U68ygXK/V8iqXu52Ga6es0s7Y69QagSxl9LCrRmfext76d@@@l4gkGxqfY8YJSR7qU42t@ZlWzKqua9BlxIRAKUFDE4KPz7MKHkHjtzBTwIxC4Q@nY5bLvdwuT9uPTrzIZUZABMaBh0ERHIGvgWIO4UjKcEW2sshPR74a9XL5Aw "Wolfram Language (Mathematica) – Try It Online")
Note that on TIO this outputs the result in escaped form. In the normal Wolfram front end, it will look like this:[![picture of notebook interface](https://i.stack.imgur.com/KFRmf.png)](https://i.stack.imgur.com/KFRmf.png)
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 107 bytes, 81 chars
```
n=>{var t="〇一二三〤〥〦〧〨〩〡〢〣";var b=0;return n.Select(k=>t[k+(b+=k>0&k<4?1:b)%2*9]);}
```
[Try it online!](https://tio.run/##XZDfSsMwFIev26cIAyVxtWxzIpq2XgwVYYKwCy/GLtKYbaFdikk6J6OQOxF8Cf/rGwxfJ3uP2noxxMvD@X6/83Go2qWZZGWuuJiAwZ3SbIbdv5Pfy9KUUc0zofwzJpjk9B/R5@IGuzQlSoFLmU0kmYGl6yhNNKdgnvFrcEG4gErLKjUcASInCtWIM66OEzqFcyKB0vl4DLgACyjYLehzpQMudATRsu21vY6353W9A2@/QKhK1mmnV0llKfOvJNcM/hYgXC0Kx3WKjcFpLmiwqfPOT0Q@Y5LEKQvolMgoWoSlCKNlLaHDhjX365VZfz@uVw/WvFrzZs27NR/WfFrzZc2TNc/WvDRwzcdhC0umcymA8Aes/hRMwkgPkyaMm2EStbaToHvcPorRVmfncIRwUWK3KH8A "C# (.NET Core) – Try It Online")
Saved 17 bytes thanks to @Jo King
# Old Answer
# ~~[C# (.NET Core)](https://www.microsoft.com/net/core/platform), 124 bytes, 98 chars~~
```
n=>{var t="〇一二三〤〥〦〧〨〩〡〢〣";var b=0<1;return n.Select(k=>{b=k>0&k<4?!b:0<1;return b?t[k]:t[k+9];});}
```
[Try it online!](https://tio.run/##XZDNSsNAFIXXyVOMXUiCY2i1InaSdFFUhApCFy5KF5Nx2g5JJzgzqZUSmJ0IvoT/@gbF15m@R5y4KMXNhcv9zrmHQ@Q@yQWtCsn4BAzupaIz5G5vQS/PMkoUy7kMzimngpF/RJ/xW@SSDEsJrkQ@EXgGlq4jFVaMgHnObsAlZtyTSljVcASwmEi/RpyxfY7J1JtjAaQqxmPAOFh4nN6BPpMqZFzFnr9swRY8gIewDY/hUen7VlmrnZ4NlWc0uBZMUe/PwEf2UDquU24SnBWchBs7eHHKixkVOMloSKZYxPEiqngUL@sQKmoY/bBe6fXP03r1aPSb0e9Gfxj9afSX0d9GPxv9YvRrA9V8EjXDFhJUFYIDHgxo3ZWXWrckSuPmbhq2uztJZwtKumqYjjp27J2MUOmjskJuWf0C "C# (.NET Core) – Try It Online")
Takes input in the form of a List, and returns an IEnumerable. I don't know if this input/output is ok, so just let me know if it isn't.
# Explanation
How this works is that it transforms all the integers to their respective Suzhou numeral form, but only if variable `b` is true. `b` is inverted whenever we meet an integer that is one, two, or three, and set to true otherwise. If `b` is false, we turn the integer to one of the vertical numerals.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 55 bytes
```
s"〇〡〢〣〤〥〦〧〨〩"
ð"[〡〢〣]" óÈ¥YÉÃ®ë2,1Ãc
£VøY ?Xd"〡一〢二〣三":X
```
[Try it online!](https://tio.run/##y0osKPn/v1jpcUP744aFjxsWPW5Y/LhhyeOGpY8blj1uWP64YcXjhpVKXIc3KEXDFcQqKRzefLjj0NLIw52Hmw@tO7zaSMfwcHMy16HFYYd3RCrYR6QADVz4ZEcDUP2TXT1ALU92dCpZRfz/H22ow2UIxEamOlymBjpclpYgPlDAFCxqYGgB5BsZGxsZgmkTMMPSwtzMFMQ0iOXSDcoFAA "Japt – Try It Online")
It's worth noting that TIO gives a different byte count than my [preferred interpreter](https://ethproductions.github.io/japt/?v=1.4.6&code=cyJcdTMwMDdcdTMwMjFcdTMwMjJcdTMwMjNcdTMwMjRcdTMwMjVcdTMwMjZcdTMwMjdcdTMwMjhcdTMwMjkiCvAiW1x1MzAyMVx1MzAyMlx1MzAyM10iIPPIpVnJw67rMiwxw2MKo1b4WSA/WGQiXHUzMDIxXHU0ZTAwXHUzMDIyXHU0ZThjXHUzMDIzXHU0ZTA5IjpY&input=WzEsCjExLAoyNSwKNTAsCjk5LAoxMTEsCjUxMSwKMjAxOCwKMTIzMzIxLAoxMjM0MzIxLAo5ODc2NTQzMjEwXQotUm0=), but I see no reason not to trust the one that gives me a lower score.
Explanation:
```
    Step 1:
s"〇〡〢〣〤〥〦〧〨〩"        Convert the input number to a string using these characters for digits
    Step 2:
ð                            Find all indexes which match this regex:
 "[〡〢〣]"                    A 1, 2, or 3 character
           ó    Ã            Split the list between:
            È¥YÉ              Non-consecutive numbers
                  ®    Ã     For each group of consecutive [1,2,3] characters:
                   ë2,1      Get every-other one starting with the second
                        c    Flatten
    Step 3:
£                              For each character from step 1:
 VøY                           Check if its index is in the list from step 2
     ?                         If it is:
      Xd"〡一〢二〣三"            Replace it with the horizontal version
                     :X        Otherwise leave it as-is
```
[Answer]
# [R](https://www.r-project.org/), 104 bytes
```
function(x,`[`=chartr)"a-jBCD"["〇〡-〩一二三",gsub("[bcd]\\K([bcd])","\\U\\1","0-9"["a-j",x],,T)]
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQichOsE2OSOxqKRIUylRN8vJ2UUpWulxQ/vjhoW6jxtWPtnR8GRXz5MdnUo66cWlSRpK0UnJKbExMd4aYIamko5STExoTIwhkGGgawnUCzRESaciVkcnRDP2f5qGuqG6prICHACN5QIJoogCBYH2gMSNTFHFFz1uWAoSNzVAFV8KdCFI3NISVXwlEEHMR7YAYj7UalM0qaVIthsYWiDkwLaDwuFxwwqwmUbGxkZwvSBdu3oeNywGhg1QJdQEoBoThCK4mscNS0AqQWywGywtzM1MQQrB3gI7e8XjhuWPG5aB3YNQDHTAfwA "R – Try It Online")
An alternative approach in R. Makes use of some Perl-style Regex features (the last `T` param in substitution function stands for `perl=TRUE`).
First, we translate numerals to alphabetic characters `a-j`, then use Regex substitution to convert duplicate occurrences of `bcd` (formerly `123`) to uppercase, and finally translate characters to Suzhou numerals with different handling of lowercase and uppercase letters.
Credit to J.Doe for the preparation of test cases, as these were taken from [his answer](https://codegolf.stackexchange.com/a/177544/78274).
[Answer]
# C#, 153 bytes
```
n=>Regex.Replace(n+"",@"[4-90]|[1-3]{1,2}",x=>"〇〡〢〣〤〥〦〧〨〩"[x.Value[0]-'0']+""+(x.Value.Length>1?"一二三"[x.Value[1]-'0'-1]+"":""))
```
[Try it online!](https://tio.run/##hVDPToMwHL7zFE0vgwgE2KbiHGqMnmZi1OiBcGiwIgkrpAWDmUt6Mya@hP/1DRZfp3sPhDHdLrLv0OT3/enva32m@THFRcZCEoDTW5biYU9anvQznKf6CQ6yCNGDPKGYsTAmrCcRNMQsQT4G@@UcR3gvSUxpJIESfoQYA8c0Digazpiar8BSlIY@uInDS3CEQiKzlJb7XA8gGjDlz7dIVDjMiL8dxSRQQe13wFVJgX5B@k5ZD@dlySQq68hkDUJ1F7odzTa8O9fU2t7IVK0xVPO@AwW/F/xJ8GfBXwR/FfxN8HfBPwT/FPwLurl@jqIMu4antYyWV961Js85fYBJkF475g6cTvj0@3E6eVgEzFlAM6vIFoSKUvSW@ku/v6Rf0DDFg5BguXqAbCpK73@xUbW6TWrXaFJtu3lvcy2r3bZWOTorLPbmxnq3MtU95xhL9TmWih8)
]