सूज़ौ अंकों में परिवर्तित करें

27

सूज़ौ अंक (蘇州 碼子; भी 碼 蘇州) चीनी दशमलव अंक हैं:

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

वे अरबी अंकों की तरह बहुत काम करते हैं, सिवाय इसके कि जब सेट से संबंधित लगातार अंक होते हैं {1, 2, 3}, तो अंक अस्पष्टता से बचने के लिए ऊर्ध्वाधर स्ट्रोक नोटेशन {〡,〢,〣}और क्षैतिज स्ट्रोक नोटेशन के बीच वैकल्पिक होते हैं {一,二,三}। इस तरह के लगातार समूह का पहला अंक हमेशा ऊर्ध्वाधर स्ट्रोक संकेतन के साथ लिखा जाता है।

कार्य एक सकारात्मक पूर्णांक को सूज़ौ अंकों में बदलना है।

परीक्षण के मामलों

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

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  number  unicode 
— u54112
स्रोत
1
मैं सुज़ो 3 बार लंबे समय तक (काफी अच्छा शहर) रहा हूँ, लेकिन सूज़ौ अंकों के बारे में नहीं जानता था। आपके पास मेरा +1
— थॉमस वेलर
2
@ThomasWeller मेरे लिए यह विपरीत है: इस कार्य को लिखने से पहले मुझे पता था कि अंक क्या थे, लेकिन यह नहीं कि उन्हें "सूज़ौ अंक" नाम दिया गया था। वास्तव में मैंने कभी उन्हें यह नाम नहीं सुना (या किसी भी नाम पर)। मैंने उन्हें बाजारों में और हस्तलिखित चीनी चिकित्सा नुस्खों पर देखा है।
— u54112
क्या आप एक वर्ण सरणी के रूप में इनपुट ले सकते हैं?
— अज्ञानता
@EmbodimentofIgnorance हाँ। वैसे, पर्याप्त लोग वैसे भी स्ट्रिंग इनपुट ले रहे हैं।
— u54112

जवाबों:

9

आर , 138 बाइट्स

मुझे यकीन है कि ऐसा करने का एक आसान तरीका होगा। gsubवैकल्पिक संख्यात्मक पदों को प्राप्त करने के लिए उपयोग करें ।

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

इसे ऑनलाइन आज़माएं!

— J.Doe
स्रोत
8

रेटिना , 46 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

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

दो अंकों के 1-3 या किसी अन्य अंक से मिलान करें।

_T`d`〇〡-〩`^.

प्रत्येक मैच के पहले चरित्र को उसके सूज़ौ से बदलें।

T`123`一二三

किसी भी शेष अंक को क्षैतिज सूज़ौ से बदलें।

रेटिना 0.8.2 में 51 बाइट्स :

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

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। स्पष्टीकरण:

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

यदि वे दोनों 1-3 हैं, तो इनपुट को व्यक्तिगत अंकों या अंकों के जोड़े में विभाजित करें।

mT`d`〇〡-〩`^.

प्रत्येक पंक्ति के पहले वर्ण को उसके सूज़ौ से बदलें।

T`¶123`_一二三

एक साथ वापस लाइनों में शामिल हों और क्षैतिज सूज़ौ के साथ किसी भी शेष अंक को बदलें।

— नील
स्रोत
7

पर्ल 5 -pl -Mutf8 , 53 46 बाइट्स

-7 बाइट्स ग्रिम के लिए धन्यवाद

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

इसे ऑनलाइन आज़माएं!

व्याख्या

# 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
— nwellnhof
स्रोत
-3 के साथ बाइट्स s/[123]\K[123]/$&^$;/ge;y/--</一二三〇〡-〩/( TIO )
— ग्रिमी
49: s/[123]{2}/$&^v0.28/ge;y/--</一二三〇〡-〩/( टीआईओ )। 48: s/[123]{2}/$&^"\0\34"/ge;y/--</一二三〇〡-〩/(इसके बजाय शाब्दिक नियंत्रण वर्णों का उपयोग करने की आवश्यकता होती है \0\34, इसे TIO पर कैसे करें आइडल करें)
— ग्रैमी
46: s/[123]{2}|./OS&$&/ge;y//〇〡-〰一二三/c( टीआईओ )
— ग्रैमी
6

जावा (JDK) , 120 बाइट्स

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

इसे ऑनलाइन आज़माएं!

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
1
c=s[i]-48;if(p>0&p<4&c>0&c<4)हो सकता है if(p>0&p<4&(c=s[i]-48)>0&c<4), और फिर आप कोष्ठक को लूप के चारों ओर छोड़ सकते हैं। इसके अलावा, else{p=c;s[i]+=c<1?12247:12272;}हो सकता हैelse s[i]+=(p=c)<1?12247:12272;
— केविन क्रूज़सेन
1
@KevinCruijssen धन्यवाद! मैं अभी भी इस जवाब को गोल्फ रहा था, लेकिन इसने मुझे मदद की ^ ^ अब मुझे लगता है कि मैं इसे गोल्फ कर रहा हूं।
— ओलिवियर ग्रेजायर
5

जावास्क्रिप्ट (ईएस 6),  95 89  88 बाइट्स

6 बाइट्स को @ShieruAsakoto को धन्यवाद दिया

एक स्ट्रिंग के रूप में इनपुट लेता है।

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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
— Shieru Asakoto
@ शियरुअसाकोतो यह बहुत बेहतर है! आपका बहुत बहुत धन्यवाद!
— अरनौलड
3

स्वच्छ , 181 165 बाइट्स

सभी ऑक्टल एस्केप को समान सिंगल-बाइट वर्णों द्वारा प्रतिस्थापित किया जा सकता है (और उन्हें एक-एक बाइट के रूप में गिना जाता है), लेकिन पठनीयता के लिए उपयोग किया जाता है और क्योंकि यह अमान्य यूटीएफ -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]

इसे ऑनलाइन आज़माएं!

एन्कोडिंग-अनजान संकलक एक आशीर्वाद और अभिशाप दोनों है।

— Οurous
स्रोत
2

सी, 131 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण: सबसे पहले - मैं इसे छोटा करने के लिए सभी चर के लिए चार का उपयोग कर रहा हूं।

अर्रे sसभी आवश्यक सूज़ौ पात्रों को रखता है।

बाकी प्रदान की गई संख्या से अधिक पुनरावृति है, जो एक स्ट्रिंग के रूप में व्यक्त की जाती है।

टर्मिनल पर लिखते समय, मैं इनपुट संख्या मान (इसलिए चरित्र - ASCII में 48) का उपयोग कर रहा हूं, 3 से गुणा किया जाता है, क्योंकि ये सभी वर्ण UTF-8 में 3 बाइट्स लंबे हैं। 'स्ट्रिंग' मुद्रित होना हमेशा 3 बाइट्स लंबा होता है - इसलिए एक वास्तविक वर्ण।

चर cऔर dवर्तमान और अगले इनपुट चरित्र (संख्या) के लिए सिर्फ 'शॉर्टकट' हैं।

परिवर्तनीय f0 या 27 रखता है - यह कहता है कि अगले 1/2/3 वर्ण को वैकल्पिक एक में स्थानांतरित किया जाना चाहिए - 27 सरणी में नियमित और वैकल्पिक चरित्र के बीच ऑफसेट है।

f=c*d&&(c|d)<4&&!f?27:0 - 27 लिखने के लिए f अगर c * d! = 0 और अगर वे दोनों <4 हैं और अगर f 0 नहीं है, तो 0 लिखें।

के रूप में फिर से लिखा जा सकता है:

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

हो सकता है कि शेव करने के लिए कुछ बाइट्स हों, लेकिन मैं अब कुछ भी स्पष्ट नहीं कर पा रहा हूं।

— मिशेल स्टो
स्रोत
— जोनाथन फ्रीच
1

के (ngn / k) , 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

10\ दशमलव अंकों की सूची प्राप्त करें

{ }@ निम्नलिखित फ़ंक्शन लागू करें

x&x<4 बूलियन (0/1) की सूची जहां तर्क 4 और गैर-शून्य से कम है

<\से कम के साथ स्कैन करें। यह लगातार 1s और 0s को वैकल्पिक 1s में चलाता है

x+9* 9 से गुणा करें और जोड़ें x

juxtaposition अनुक्रमण है, इसलिए इसे सूचकांक में उपयोग करें ...

0N 3#"〇一二三〤〥〦〧〨〩〡〢〣"दी गई स्ट्रिंग, 3-बाइट स्ट्रिंग्स की सूची में विभाजित है। k यूनिकोड से अवगत नहीं है, इसलिए यह केवल बाइट्स देखता है

,/ CONCATENATE

— NGN
स्रोत
1

वोल्फ्राम भाषा (गणितज्ञ) , 117 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ध्यान दें कि TIO पर यह परिणाम के रूप में बच गए। सामान्य वुल्फराम सामने के अंत में, यह इस तरह दिखेगा:नोटबुक इंटरफ़ेस की तस्वीर

— केली लोवदर
स्रोत
1
क्या आप जुड़वाँ और पेड़ों के लिए क्षैतिज स्ट्रोक नोटेशन को लागू कर सकते हैं? जैसे f[123]लौट जाना चाहिए 〡二〣।
— u54112
1

जाप , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह ध्यान देने योग्य है कि टीआईओ मेरे पसंदीदा दुभाषिया की तुलना में एक अलग बाइट की गिनती देता है , लेकिन मुझे कोई कारण नहीं है कि जो मुझे कम स्कोर देता है उस पर भरोसा न करें।

स्पष्टीकरण:

    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
— कामिल दकरी
स्रोत
1

C # (.NET कोर) , 107 बाइट्स, 81 वर्ण

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

इसे ऑनलाइन आज़माएं!

@Jo King को 17 बाइट्स धन्यवाद से बचाया

पुराना उत्तर

C # (.NET कोर) , 124 बाइट्स, 98 वर्ण

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

इसे ऑनलाइन आज़माएं!

एक सूची के रूप में इनपुट लेता है, और एक IEnumerable देता है। मुझे नहीं पता कि यह इनपुट / आउटपुट ठीक है, इसलिए मुझे बताएं कि क्या यह नहीं है।

व्याख्या

यह कैसे काम करता है कि यह सभी पूर्णांकों को उनके संबंधित सूज़ौ अंक के रूप में बदल देता है, लेकिन केवल अगर चर bसत्य है। bजब भी हम एक पूर्णांक से मिलते हैं, जो एक, दो या तीन होता है, और अन्यथा सत्य पर सेट होता है। यदि bगलत है, तो हम पूर्णांक को ऊर्ध्वाधर अंकों में से एक में बदल देते हैं।

— अज्ञान का अवतार
स्रोत
0

आर , 104 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आर। में एक वैकल्पिक दृष्टिकोण कुछ पर्ल-स्टाइल रेगेक्स सुविधाओं का उपयोग करता है ( Tप्रतिस्थापन समारोह में अंतिम परम के लिए खड़ा है perl=TRUE)।

सबसे पहले, हम अंकों को अल्फ़ाबेटिक वर्णों में अनुवाद a-jकरते हैं, फिर रेप्क्स प्रतिस्थापन का उपयोग bcd(पूर्व 123) के डुप्लिकेट घटनाओं को अपरकेस में बदलने के लिए करते हैं, और अंत में लोअरकेस और अपरकेस अक्षरों के विभिन्न हैंडलिंग के साथ सूज़ौ अंकों में वर्णों का अनुवाद करते हैं।

टेस्ट मामलों की तैयारी के लिए जे। डी। को श्रेय, क्योंकि ये उनके जवाब से लिए गए थे ।

— किरिल एल।
स्रोत
0

सी #, 153 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— zruF
स्रोत
यह 153 बाइट्स है, वैसे, वर्णों का अर्थ हमेशा बाइट्स नहीं होता है। कुछ अक्षर कई बाइट के लायक हैं।
— अज्ञानता का अवतार
ओह ठीक है, मैंने अपना उत्तर संपादित किया। जानकारी के लिए धन्यवाद :)
— zruF
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.