Les chiffres de Suzhou (蘇州 碼子; également 花 碼) sont des nombres décimaux chinois:

0 〇
1 〡 一
2 〢 二
3 〣 三
4 〤
5 〥
6 〦
7 〧
8 〨
9 〩

Ils fonctionnent à peu près comme des chiffres arabes, sauf que lorsqu'il y a des chiffres consécutifs appartenant à l'ensemble {1, 2, 3}, les chiffres alternent entre la notation de trait vertical {〡,〢,〣}et la notation de trait horizontal {一,二,三}pour éviter toute ambiguïté. Le premier chiffre d'un tel groupe consécutif est toujours écrit avec une notation de trait vertical.

La tâche consiste à convertir un entier positif en chiffres de Suzhou.

Cas de test

1          〡
11         〡一
25         〢〥
50         〥〇
99         〩〩
111        〡一〡
511        〥〡一
2018       〢〇〡〨
123321     〡二〣三〢一
1234321    〡二〣〤〣二〡
9876543210 〩〨〧〦〥〤〣二〡〇

Le code le plus court en octets gagne.

Gelée , 35 octets

9Ḷ;-26ż“/Ẉ8‘+⁽ȷc¤ṃ@ɓD_2ỊŒgÄFị"+⁽-FỌ

Essayez-le en ligne!

R , 138 octets

Je parie qu'il existe un moyen plus simple de le faire. Utilisez gsubpour obtenir les positions numériques alternées.

function(x,r=-48+~x)Reduce(paste0,ifelse(58<~gsub("[123]{2}","0a",x),"123"["一二三",r],'0-9'["〇〡-〩",r]))
"~"=utf8ToInt
"["=chartr

Essayez-le en ligne!

JavaScript, 81 octets

s=>s.replace(/./g,c=>(p=14>>c&!p)|c>3?eval(`"\\u302${c}"`):'〇一二三'[c],p=0)

Essayez-le en ligne!

L'utilisation 14>>céconomise 3 octets. Merci à Arnauld .

Rétine , 46 octets

/[1-3]{2}|./_T`d`〇〡-〩`^.
T`123`一二三

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

/[1-3]{2}|./

Faites correspondre deux ou trois chiffres ou tout autre chiffre.

_T`d`〇〡-〩`^.

Remplacez le premier caractère de chaque match par son Suzhou.

T`123`一二三

Remplacez tous les chiffres restants par Suzhou horizontal.

51 octets dans Retina 0.8.2 :

M!`[1-3]{2}|.
mT`d`〇〡-〩`^.
T`¶123`_一二三

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

M!`[1-3]{2}|.

Divisez l'entrée en chiffres individuels ou en paires de chiffres s'ils sont tous deux 1-3.

mT`d`〇〡-〩`^.

Remplacez le premier caractère de chaque ligne par son Suzhou.

T`¶123`_一二三

Joignez les lignes ensemble et remplacez tous les chiffres restants par Suzhou horizontal.

Perl 5 -pl -Mutf8 , 53 46 octets

-7 octets grâce à Grimy

s/[123]{2}|./OS&$&/ge;y//〇〡-〰一二三/c

Essayez-le en ligne!

Explication

# 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

Java (JDK) , 120 octets

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;}

Essayez-le en ligne!

Crédits

• -3 octets grâce à Kevin Cruijssen

JavaScript (ES6),  95 89  88 octets

6 octets enregistrés grâce à @ShieruAsakoto

Prend l'entrée sous forme de chaîne.

s=>s.replace(i=/./g,c=>'三二一〇〡〢〣〤〥〦〧〨〩'[i=112>>i&c<4?3-c:+c+3])

Essayez-le en ligne!

Python 3 , 102 octets

f=0
for i in input():f=i in'123'and 9-f;print(end='〇一二三〤〥〦〧〨〩〡〢〣'[int(i)+f])

Essayez-le en ligne!

mypetlion m'a rappelé un golf insignifiant. -4 octets.

Nettoyer , 181 165 octets

Tous les échappements octaux peuvent être remplacés par les caractères mono-octet équivalents (et sont comptés comme un octet chacun), mais utilisés pour la lisibilité et parce qu'autrement, il casse TIO et SE avec UTF-8 invalide.

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]

Essayez-le en ligne!

Un compilateur ignorant l'encodage est à la fois une bénédiction et une malédiction.

Perl 6 -p , 85 61 octets

-13 octets grâce à Jo King

s:g[(1|2|3)<((1|2|3)]=chr $/+57;tr/0..</〇〡..〩一二三/

Essayez-le en ligne!

Rouge , 198 171 octets

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]

Essayez-le en ligne!

Gelée , 38 octets

9Rż“øƓ“œ%“øƈ’;-25+⁽-EỌœị@DżD<4«Ɗ‘×¥\ƊƊ

Essayez-le en ligne!

C, 131 octets

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]);}

Essayez-le en ligne!

Explication: Tout d'abord - j'utilise char pour toutes les variables pour faire court.

Array scontient tous les personnages Suzhou nécessaires.

Le reste est à peu près itéré sur le nombre fourni, qui est exprimé sous forme de chaîne.

Lors de l'écriture sur le terminal, j'utilise la valeur du numéro d'entrée (donc le caractère - 48 en ASCII), multipliée par 3, car tous ces caractères font 3 octets de long en UTF-8. La «chaîne» en cours d'impression est toujours de 3 octets - donc un vrai caractère.

Les variables cet ne dsont que des «raccourcis» vers le caractère d'entrée actuel et suivant (nombre).

Variable f contient 0 ou 27 - elle indique si le caractère 1/2/3 suivant doit être déplacé vers l'alternative - 27 est le décalage entre le caractère régulier et alternatif dans le tableau.

f=c*d&&(c|d)<4&&!f?27:0 - écrivez 27 à f si c * d! = 0 et s'ils sont tous les deux <4 et si f n'est pas 0, sinon écrivez 0.

Pourrait être réécrit comme:

if( c && d && c < 4 && d < 4 && f == 0)
f = 27
else
f = 0

Il y a peut-être quelques octets à raser, mais je ne trouve plus rien d'évident.

Rubis -p , 71 octets

$_=gsub(/[1-3]\K[1-3]/){|x|(x.ord+9).chr}.tr"0-<","〇〡-〩一二三"

Essayez-le en ligne!

K (ngn / k) , 67 octets

{,/(0N 3#"〇一二三〤〥〦〧〨〩〡〢〣")x+9*<\x&x<4}@10\

Essayez-le en ligne!

10\ obtenir la liste des chiffres décimaux

{ }@ appliquer la fonction suivante

x&x<4 liste booléenne (0/1) où l'argument est inférieur à 4 et non nul

<\numériser avec moins de. cela transforme les cycles de 1 consécutifs en alternance de 1 et de 0

x+9* multipliez par 9 et ajoutez x

la juxtaposition est l'indexation, alors utilisez-la comme index dans ...

0N 3#"〇一二三〤〥〦〧〨〩〡〢〣"la chaîne donnée, divisée en une liste de chaînes de 3 octets. k n'est pas unicode, il ne voit donc que les octets

,/ enchaîner

Wolfram Language (Mathematica) , 117 octets

FromCharacterCode[12320+(IntegerDigits@#/. 0->-25//.MapIndexed[{a___,c=#2[[1]],c,b___}->{a,c,#,b}&,{0,140,9}+7648])]&

Essayez-le en ligne!

Notez que sur TIO cela génère le résultat sous forme d'échappement. Dans le front-end Wolfram normal, cela ressemblera à ceci:

Japt , 55 octets

s"〇〡〢〣〤〥〦〧〨〩"
ð"[〡〢〣]" óÈ¥YÉîë2,1Ãc
£VøY ?Xd"〡一〢二〣三":X

Essayez-le en ligne!

Il est à noter que TIO donne un nombre d'octets différent de celui de mon interprète préféré , mais je ne vois aucune raison de ne pas faire confiance à celui qui me donne un score inférieur.

Explication:

    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

C # (.NET Core) , 107 octets, 81 caractères

n=>{var t="〇一二三〤〥〦〧〨〩〡〢〣";var b=0;return n.Select(k=>t[k+(b+=k>0&k<4?1:b)%2*9]);}

Essayez-le en ligne!

17 octets enregistrés grâce à @Jo King

Ancienne réponse

C # (.NET Core) , 124 octets, 98 caractères

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];});}

Essayez-le en ligne!

Prend l'entrée sous la forme d'une liste et renvoie un IEnumerable. Je ne sais pas si cette entrée / sortie est correcte, alors faites le moi savoir si ce n'est pas le cas.

Explication

Comment cela fonctionne, c'est qu'il transforme tous les entiers en leur forme numérique respective de Suzhou, mais seulement si la variable best vraie. best inversé chaque fois que nous rencontrons un entier qui est un, deux ou trois, et défini sur true sinon. Si best faux, nous transformons l'entier en l'un des chiffres verticaux.

R , 104 octets

function(x,`[`=chartr)"a-jBCD"["〇〡-〩一二三",gsub("[bcd]\\K([bcd])","\\U\\1","0-9"["a-j",x],,T)]

Essayez-le en ligne!

Une approche alternative dans R. Utilise certaines fonctionnalités Regex de style Perl (le dernier Tparamètre de la fonction de substitution signifie perl=TRUE).

Tout d'abord, nous traduisons les chiffres en caractères alphabétiques a-j, puis utilisons la substitution Regex pour convertir les occurrences en double de bcd(anciennement123 ) en majuscules, et enfin traduisons les caractères en chiffres de Suzhou avec une gestion différente des lettres minuscules et majuscules.

Nous remercions J.Doe pour la préparation des cas de test, car ceux-ci sont tirés de sa réponse .

C #, 153 octets

n=>Regex.Replace(n+"",@"[4-90]|[1-3]{1,2}",x=>"〇〡〢〣〤〥〦〧〨〩"[x.Value[0]-'0']+""+(x.Value.Length>1?"一二三"[x.Value[1]-'0'-1]+"":""))

Essayez-le en ligne!