मूल संख्या (II)

Question

यह चुनौती अनिवार्य रूप से केवल एक अंतर के साथ इस के समान है : इसे अब स्ट्रिंग में कहीं भी अक्षरों में फेरबदल करने की अनुमति है।

परिदृश्य

जॉन के पास एक महत्वपूर्ण संख्या है, और वह नहीं चाहता कि अन्य इसे देखें।

उन्होंने निम्नलिखित चरणों का उपयोग करके संख्या को एन्क्रिप्ट करने का निर्णय लिया:

उनकी संख्या हमेशा एक गैर-घटता क्रम है (यानी। "1123")

उन्होंने प्रत्येक अंक को अंग्रेजी शब्दों में बदल दिया। (यानी। "123" -> "ONETWOTHREE")

और फिर, अक्षरों को यादृच्छिक रूप से पुनर्व्यवस्थित करें। (यानी। "ONETWOTHREE" -> "EEWOOHRNTET")

जॉन को लगा कि ऐसा करने में उनका नंबर सुरक्षित है। वास्तव में, ऐसे एन्क्रिप्शन को आसानी से डिक्रिप्ट किया जा सकता है :(

---

कार्य

एन्क्रिप्ट किए गए स्ट्रिंग s को देखते हुए, आपका कार्य इसे डिक्रिप्ट करना और मूल संख्या वापस करना है।

---

नियम

• यह कोड गोल्फ है, इसलिए बाइट्स जीत में सबसे छोटा जवाब है
• आप मान सकते हैं कि इनपुट स्ट्रिंग हमेशा मान्य है
• इनपुट स्ट्रिंग में केवल बड़े अक्षर हैं
• मूल संख्या हमेशा आरोही क्रम में व्यवस्थित होती है
• आप स्ट्रिंग या पूर्णांक प्रारूप में संख्या वापस कर सकते हैं
• अक्षरों को केवल एक शब्द के बीच फेरबदल किया जाएगा, पूरे स्ट्रिंग के बीच नहीं। पत्र स्ट्रिंग में कहीं भी फेरबदल किया जा सकता है।
• संख्या केवल 1 से 9 समावेशी करने के लिए किया जाएगा ( ONEकरने के लिए NINE)

---

संभव असत्य स्ट्रिंग

यहाँ तार की एक सूची दी गई है, जब वे संख्याओं से तार में परिवर्तित हो गए हैं:

 1 -> ONE 
 2 -> TWO
 3 -> THREE
 4 -> FOUR
 5 -> FIVE
 6 -> SIX
 7 -> SEVEN
 8 -> EIGHT
 9 -> NINE

---

उदाहरण

"NEO" -> 1

"NWEOOT" -> 12

"TOEERWNEHOT" -> 123

"IHNEVGENNEISTE" -> 789

"WEETVTRFSVUHNEEFRHIXEOINSNIEGTOONIEE" -> 123456789

"EWHEWROETOTTON" -> 1223

"ONEWESTV" -> 27 (धन्यवाद, ETHproductions!)

Comments

सुझाया गया टेस्ट केस: कुछ ऐसा "ONEWESTV" -> 27(जिसमें एक नंबर शामिल है जो वास्तव में प्रकट नहीं होता है)

— ETHproductions

@ETHproductions महान विचार! जोड़ा गया।

— क्रिस्टियन लुपस्कु

"शून्य" क्यों नहीं है?

— रोजलूपी

@RosLuP जॉन को अग्रणी शून्य से नफरत है ...

— क्रिस्टियन

Answer 1

पायथन 2 , 123 बाइट्स

c=map(input().count,"OWHUFXSGIQ")
i=4
for j in"71735539994":c[i*2]-=c[int(j)];i=-~i%5
s=""
for n in c:i+=1;s+=`i`*n
print s

एक पूरा कार्यक्रम उद्धृत इनपुट और जॉन के नंबर को प्रिंट करता है।

इसे ऑनलाइन आज़माएं!या एक परीक्षण-सूट देखें

कैसे?

आइए उदाहरण के साथ काम करें "NEONSEXTOWNII" (1269 उपज देने के लिए, और कुछ हद तक आराम लैरी लैरी हो लेस हो!)

पहले c=map(input().count,"OWHUFXSGIQ")इनपुट लेता है और प्रत्येक की संख्या को गिनता है OWHUFXSGIQ- ये ऐसे अक्षर हैं जो प्रत्येक संख्या में आरोही क्रम में दिखाई देते हैं, 2,4,6 के साथ, और 8 में उनके "स्वयं" अक्षर ( WUXG), और एक अतिरिक्त अक्षर, Qएक शून्य को जोड़ने के लिए हैं। अंत तक और परिणामी सूची की लंबाई भी बनाएं। उदाहरण के लिए:

[2,1,0,0,0,1,1,0,2,0] <- c
 O W H U F X S G I Q  <- is the counts of these letters
 1 2 3 4 5 6 7 8 9 0  <- which "relate to" these digits in John's number
   2   4   6   8   0  <- these will be correct as the letters are unique to their words

1, 3, 5, 7 और 9 के लिए प्रविष्टियों को अन्य अक्षरों की बहुतायत को सही करने के लिए समायोजन की आवश्यकता होती है। यह अगले लूप द्वारा किया जाता है:

i=4
for j in"71735539994":c[i*2]-=c[int(j)];i=-~i%5

ध्यान दें कि समायोजित करने वाली प्रविष्टियाँ वैकल्पिक हैं (1,3,5,7,9,1,3,5, ...), इसलिए हम प्रत्येक चरण में दो इंडेक्स चर जोड़ सकते हैं और 10 तक रहने के लिए modulo रेंज अगर हमें एक से अधिक बार (जो हम करते हैं) को पार करने की आवश्यकता है। कुछ बाइट्स को बचाने के लिए हम एक और मोडुलो को 5 से बढ़ा सकते हैं और इंडेक्स को दोगुना कर सकते हैं।
चूंकि 9 के समायोजन में हमें सबसे अधिक काम की आवश्यकता होती है - यह सूचकांक 8 पर रहता है इसलिए हम शुरू करते हैं i=4। स्ट्रिंग "71735539994"तब jप्रत्येक चरण में हटाने के मूल्यों का सूचकांक देता है, (जहां हमने यह सुनिश्चित किया है कि नौवें सूचकांक का उपयोग करते "Q"समय शून्य होगा c); c[i*2]-=c[int(j)]प्रत्येक व्यक्ति के समायोजन और प्रदर्शन i=-~i%5चाल iअगले सूचकांक (जहां -~iहै -(-1-i)या i+1बचत कोष्ठक (i+1)%5) रखते हुएi*2 की सीमा के भीतर c।
इस प्रकार हम सबसे पहले सूचकांक में उस संख्या को सूचकांक j=7से i*2=8घटाते हैं, "I" s की संख्या से गिने गए "G" की संख्या को घटाते हुए, "EIGHT" की (सही) संख्या से "NINE" की संख्या को समायोजित करते हैं ( जिसमें एक "I" भी है)। फिर हम i=0( -~4%5 = (4+1)%5 = 0) को संदर्भित करते हैं, i*2 = 0जो "एक" के लिए होता है और सूचकांक j=1में दर्ज मूल्य को घटाकर "W" और इसलिए "TWO" की तरह घटाता है , जिससे "O" की गिनती समायोजित हो जाती है। लूप के अंत तक हमारे पास सही मायने रखता है:

[1,1,0,0,0,1,0,0,1,0] <- c   (for 1223333448 it would be: [1,2,4,2,0,0,0,1,0,0])
 1 2 3 4 5 6 7 8 9 0

इसलिए जो कुछ भी बचा हुआ है उसे प्रिंट करना है जो cअब प्रतिनिधित्व करता है ( 1269)। iअब वापस आ गया है 0, इसलिए हम इसे लूप की शुरुआत में बढ़ाते हैं और इसे हमारे अंक के रूप में उपयोग करते हैं:

s=""
for n in c:i+=1;s+=`i`*n
print s

वापस टिक, `i`, को Python2 हैं आशुलिपि के लिए repr(i)जो एक संख्या creats द्वारा कि कई दोहराता (का एक नया स्ट्रिंग यहाँ हम केवल दिखाने के लिए एक वस्तु (स्ट्रिंग के रूप में सवाल अंकों चरित्र) के एक स्ट्रिंग प्रतिनिधित्व और गुणा एक स्ट्रिंग हो जाता है n=0मोड़ `i`कहते से "5"करने के लिए ""और n=1कहते हैं रखने मोड़ "6"के रूप में "6", लेकिन यह भी बड़ा धनात्मक पूर्णांक के लिए काम करता है, तो "3"*4हो जाता है "3333", उदाहरण के लिए।)

Answer 2

05AB1E , 31 बाइट्स

[{‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#NSèJ{Q#

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

व्याख्या

[                                   # start loop
 {                                  # sort input
  ‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#            # push the list ['Z','ONE','TWO','THREE','FOUR','FIVE','SIX','SEVEN','EIGHT','NINE']
                        N           # push the current iteration counter
                         S          # split to list of digits
                          è         # index into the list with each
                           J{       # join to string and sort
                             Q#     # if the strings are equal, exit loop
                                    # implicitly print iteration counter

बड़े इनपुट के लिए बहुत अक्षम है।

Comments

‘Z€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘# # push the list ['Z','ONE','TWO','THREE','FOUR','FIVE','SIX','SEVEN','EIGHT','NINE']: क्या आप थोड़ा समझा सकते हैं, मैं यह समझने के लिए संघर्ष करता हूं कि किसी भी स्ट्रिंग को कैसे उत्पन्न किया जा सकता है।

— सिरिल गैंडन

@ साइरिलगंडन: ‘अंतरिक्ष के अलग-अलग शब्दों के ऊपरी-मामले संकुचित स्ट्रिंग का परिसीमन करता है। Zका मतलब है Z। अन्य सभी 2-प्रतीक जोड़े 05AB1E के शब्दकोष से एक संकुचित शब्द को दर्शाते हैं । उदाहरण के लिए €µअनुवाद के रूप में ONE।

— एमिगॉन

अच्छा है, आप शब्दकोश में एक स्ट्रिंग को कैसे संपीड़ित करते हैं? जोड़ी के यूनिकोड मूल्य के साथ कुछ?

— सिरिल गैंडन

@CyrilGandon: आप शब्द की पंक्ति संख्या को डिक्टेट में ( हैलो के लिए 2420 ) और घटाएँ 1. यह हमें देता है 2419। प्रतीकों हम जरूरत प्रतीकों जो द्वारा पीछा कर रहे हैं 24और 19में डॉक्स । हमारे मामले में यह है , 24=Ÿऔर 19=™ऐसा HELLOही होगा‘Ÿ™‘

— Emigna

अदनान द्वारा लिखित एक कंप्रेसर भी है जिसे आप ज्यादातर उदाहरणों में उपयोग कर सकते हैं। लिंक थोड़ा लंबा है, लेकिन आप इसे 05AB1E चैट रूम में पा सकते हैं । यह पूछने के लिए भी एक अच्छी जगह है कि क्या कोई और सवाल है :)

— एमिगॉन

Answer 3

रेटिना , 112 97 बाइट्स

O`.
}`GH
8
X
6
H
3
+`F(.*)O(.*)U
4$1$2
+`O(.*)W
2$1
+`F(.*)V
5$1
+`N(.*)V
7$1
}`NO
1
NN
9
T`L
O`.

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

-12 बाइट्स @ @ नील को धन्यवाद

ट्रांसपोज़िशन में एल चरित्र वर्गों के उपयोग से -3 बाइट्स

यह काम किस प्रकार करता है

मूल रूप से, यह इस तथ्य पर निर्भर करता है कि अक्षरों का उपयोग केवल कुछ निश्चित नामों में किया जाता है। उदाहरण के लिए SIXकेवल एक नाम है जिसमें एक है X। यह इस तथ्य के साथ पेचीदा हो जाता है कि कुछ शब्द अक्षरों में ओवरलैप करते हैं, जैसे कि दोनों FIVEऔर SEVENउपयोग करना V। के FIVEसाथ पहचान करके इसे ठीक किया जा सकता है F(.*)V।

Comments

@RickHitchcock फिक्स्ड। 8 में रूपांतरण पर पुनरावृत्ति ठीक से काम नहीं कर रही थी

— फायरफ्लेम 241

@RickHitchcock। उन सभी के लिए पुनरावृत्ति को निश्चित किया।

— फायरफ्लेम 241

Annoyingly GHऔर NOआसन्न हो सकता है, किसी भी पिछले के लिए छोड़कर 8या 1एक पूर्व प्रतिस्थापन से ...

— नील

शायद }`GH 8इसके लिए काम करेगा 8- }इससे पात्रों को फिर से छांटा जाएगा, इस प्रकार किसी भी शेष Gऔर Hएक साथ रखा जाएगा।

— नील

@ नील अच्छा विचार। मैं उस के लिए भी सक्षम था NO -> 1, जो सुविधाजनक था।

— फायरफ्लेम 241

Answer 4

कोटलिन 1.1 , 359 352 331 327 325 बाइट्स

प्रस्तुत करने

fun r(r:String):String{var s=""
val f=r.split(s).groupingBy{it}.eachCount()
val c=Array(10,{0})
c[8]=f["G"]?:0
c[6]=f["X"]?:0
c[4]=f["U"]?:0
c[2]=f["W"]?:0
c[1]=(f["O"]?:0)-c[2]-c[4]
c[3]=(f["R"]?:0)-c[4]
c[7]=(f["S"]?:0)-c[6]
c[5]=(f["V"]?:0)-c[7]
c[9]=((f["N"]?:0)-c[1]-c[7])/2
for(i in 1..9)for(x in 1..c[i])s+=i
return s}

कोटलीन 1.1 के समर्थन में नहीं होने के कारण TryItOnline पर काम नहीं करता है

परीक्षा

fun r(r:String):String{
val f=r.split("").groupingBy{it}.eachCount()
val c=Array(10,{0})
c[8]=f["G"]?:0
c[6]=f["X"]?:0
c[4]=f["U"]?:0
c[2]=f["W"]?:0
c[1]=(f["O"]?:0)-c[2]-c[4]
c[3]=(f["R"]?:0)-c[4]
c[7]=(f["S"]?:0)-c[6]
c[5]=(f["V"]?:0)-c[7]
c[9]=((f["N"]?:0)-c[1]-c[7])/2
var s=""
for(i in 1..9)for(x in 1..c[i])s+=i
return s}

data class TestData(val input: String, val output: String)

fun main(vararg args:String) {
    val items = listOf(
    TestData("NEO" , "1"),
    TestData("NWEOOT" , "12"),
    TestData("TOEERWNEHOT" , "123"),
    TestData("IHNEVGENNEISTE" , "789"),
    TestData("WEETVTRFSVUHNEEFRHIXEOINSNIEGTOONIEE" , "123456789"),
    TestData("EWHEWROETOTTON" , "1223")
    )
    for (item in items) {
        val out = r(item.input)
        if (out != item.output) {
            throw AssertionError("Bad result: $item : $out")
        }
    }
}

तर्क

मैंने प्रत्येक पत्र को हल करने के लिए सबसे सरल तरीके से काम करने के लिए ऊपर दी गई शीट का उपयोग किया

• हरा = अपने आप हल
• नीला = हल करने के लिए साग चाहिए
• ऑरेंज = हल करने के लिए ब्लूज़ चाहिए
• लाल = हल करने के लिए संतरे की जरूरत

संपादित करता

• -7 - व्हॉट्सएप w0lf द्वारा बदलता है
• -21 - श्रंक लिस्टऑफ को अर्रे
• -4 - हटाए गए अनावश्यक कोष्ठक
• 0 - में जोड़ा गया तर्क
• -2 - केविन-क्रूज़सेन के लिए खाली स्ट्रिंग का पुनः उपयोग

Comments

बस मैंने एक समान दृष्टिकोण का उपयोग करते हुए अपने जावा 8 उत्तर (127 बाइट्स) के साथ वास्तव में आपके साथ बांधा है । ;) लेकिन एक सवाल: क्या आप नहीं बदल सकते हैं var s=""और return sकरने के लिए r=""और return rइनपुट-स्ट्रिंग, उस बिंदु पर जो अब आपको नहीं चाहिए पुन: उपयोग से? मैंने पहले कभी कोटलिन में प्रोग्राम नहीं किया था, इसलिए यह हो सकता है कि मैं यहां बकवास बात करूं। ; पी

— केविन क्रूज़सेन

दुर्भाग्य से नहीं> discuss.kotlinlang.org/t/...

— jrtapsell

आह हाँ, यह निश्चित रूप से एक संभावना थी; पैरामीटर finalडिफ़ॉल्ट रूप से। हम्म, एक और चीज जो आप गोल्फ में सक्षम हो सकते हैं: var s=""विधि में पहली चीज के रूप में रखें , और उसके val f=r.split("").साथ बदलें val f=r.split(s).। फिर, अगर यह काम करता है तो कोई विचार नहीं है। बहुत बुरा TIO अभी तक v1.1 का समर्थन नहीं करता है, नहीं तो मैं खुद को बेवकूफ बनाने से पहले इन सुझावों को खुद

— आज़माऊंगा

Answer 5

जेली , 37 बाइट्स

1ðDị“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»ŒuḲ¤ẎŒ!ċð1#

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

-1 जोनाथन एलन को धन्यवाद ।

Comments

कुछ आदानों 7 वर्ण (: पूर्व की तुलना में बड़ा के लिए बाहर इस बार NINEFIVE, THREEFIVE)। क्या यह बग है, या कोड सिर्फ अक्षम है?

— क्रिस्टियन लुपस्कू

@ w0lf बाद वाले ( Œ!"क्रमपरिवर्तन" का अर्थ है)

— आउटगॉल्फ

"एए" के बजाय "एए" का उपयोग करके एक बाइट को बचाएं ...“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»...

— जोनाथन एलन

@JonathanAllan ओह एए एक शब्द है?

— आउटगॉल्फ

यह संक्षिप्त शब्दकोश में पहला शब्द है, हाँ।

— जोनाथन एलन

Answer 6

जावा 8, 248 234 बाइट्स

s->{int x=0,a[]=new int[10];for(String t:"2WO;4UORF;6XSI;8GI;5FI;7S;3R;1O;9I".split(";"))for(;s.indexOf(t.charAt(1))>=0;a[t.charAt(0)-48]++)for(String z:t.split(""))s=s.replaceFirst(z,"");for(s="";x++<9;)for(;a[x]-->0;)s+=x;return s;}

कोड स्पष्टीकरण:

s->{
    // Array to count how often which number appears
    int a[]=new int[10];
    // The first character behind the number serves the identification
    // the other characters get removed to identify the other numbers later
    for(String t:"2WO;4UORF;6XSI;8GI;5FI;7S;3R;1O;9I".split(";"))
        // Check if the string contains the id 
        for(;s.indexOf(t.charAt(1))>=0;a[t.charAt(0)-48]++)
            // Remove the relevant charcters
            for(String z:t.split(""))
                s=s.replaceFirst(z,"");
    // Clear the string to write the output
    s="";
    // write the numbers sequential into the output 
    for(int x=0;x++<9;)
        for(;a[x]-->0;)
            s+=x;
    return s;
}

-14 ओलिवियर ग्रेगोइरे को धन्यवाद

Comments

234 बाइट्स

— ओलिवियर ग्राएगोइरे

Answer 7

जावा 8, 346 345 344 336 327 बाइट्स

s->{int g=c(s+=" ","G"),u=c(s,"U"),w=c(s,"W"),x=c(s,"X"),f=c(s,"F")-u,h=c(s,"H")-g,v=c(s,"V")-f,o=c(s,"O")-u-w,i=c(s,"I")-f-x-g;return d(s=d(s=d(s=d(s=d(s=d(s=d(s=d(s=d("",o,1),w,2),h,3),u,4),f,5),x,6),v,7),g,8),n,9);}int c(String...s){return~-s[0].split(s[1]).length;}String d(String s,int i,int n){for(;i-->0;s+=n);return s;}

इसे यहाँ आज़माएँ।

सामान्य स्पष्टीकरण:

मैंने वर्णमाला में प्रत्येक वर्ण की घटनाओं को देखा है:

E 13357789
F 45
G 8
H 38
I 5689
N 1799
O 124
R 34
S 67
T 238
U 4
V 57
W 2
X 6

• मैंने पहले एकल-मिलान वाले पात्रों की सभी घटनाओं को गिना: G=8; U=4; W=2; X=6 :।
• फिर दो-मिलान वर्ण, जो भी चार में से एक के ऊपर से मेल खाते हैं, जो मैं उनके गिनती से घटा सकते की सभी घटनाओं: F=5; H=3।
• फिर मैंने V=7(घटाकर) फिर से वही कियाF=5 ) ।
• फिर तीन मैचों के सभी पात्र जो बचे थे: O=1; N=9 :।
  • लेकिन क्योंकि Nइसमें दो घटनाएं होती हैं , इसलिए मुझे हर घटना के लिए NINEएक अतिरिक्त करना था , इसलिए मैंने इसके बजाय (पिछले दो के बजाय तीन पिछले मैचों को घटाकर) इस्तेमाल किया है।-1NI=9

कोड स्पष्टीकरण:

s->{                    // Method with String as parameter and return-type
  int g=c(s+=" ","G"),  //  Amount of 8s (and append a space to `s` first, for the .split)
      u=c(s,"U"),       //  Amount of 4s
      w=c(s,"W"),       //  Amount of 2s
      x=c(s,"X"),       //  Amount of 6s
      f=c(s,"F")-u,     //  Amount of 5s
      h=c(s,"H")-g,     //  Amount of 3s
      v=c(s,"V")-f,     //  Amount of 7s
      o=c(s,"O")-u-w,   //  Amount of 1s
      i=c(s,"I")-f-x-g; //  Amount of 9s
  return d(             //  Return the result by:
   s=d(
    s=d(
     s=d(
      s=d(
       s=d(
        s=d(
         s=d(
          s=d("",       //   Making the input String `s` empty, since we no longer need it
                 o,1),  //   Append all 1s to `s`
         w,2),          //   Append all 2s to `s`
        h,3),           //   Append all 3s to `s`
       u,4),            //   Append all 4s to `s`
      f,5),             //   Append all 5s to `s`
     x,6),              //   Append all 6s to `s`
    v,7),               //   Append all 7s to `s`
   g,8),                //   Append all 8s to `s`
  i,9);                 //   And then returning `s` + all 9s
}                       // End of method

int c(String...s){  // Separate method with String-varargs parameter and int return-type
                    //  `s[0]` is the input-String
                    //  `s[1]` is the character to check
  return~-s[0].split(s[1]).length;
                    //  Return the amount of times the character occurs in the String
}                   // End of separated method (1)

String d(String s,int i,int n){
               // Separate method with String and two int parameters and String return-type
  for(;i-->0;  //  Loop from the first integer-input down to 0
      s+=n     //   And append the input-String with the second input-integer
  );           //  End of loop
  return s;    //  Return the resulting String
}              // End of separated method (2)

Comments

धिक्कार है, मैंने सोचा होगा कि एक सूची में जोड़ना तो छंटनी कम होगी (यह नहीं है)। बहुत बढ़िया!

— ओलिवियर ग्रेगोइरे

ठीक है, अंत में, मैंने आपको अपमानित किया , लेकिन बहुत ज्यादा नहीं;)

— ओलिवियर

Answer 8

पर्ल ५ , 100 बाइट्स

-nस्विच के लिए 99 बाइट्स कोड + 1 बाइट ।

${$_}++for/./g;@a=($O-$W-$U,$W,$H-$G,$U,$F-$U,$X,$S-$X,$G,$I-$F+$U-$X-$G);print$_ x$a[$_-1]for 1..9

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

Answer 9

पायथन 3 , 225 बाइट्स

def f(s):
	r=[]
	for i,w in zip([2,4,6,8,3,5,7,1,9],["WTO","UFOR","XSI","GEIHT","HTREE","FIVE","VSEEN","ONE","NINE"]):
		while s.count(w[0]):
			r+=[i]
			for l in w:s="".join(s.split(l,1))
	return "".join(sorted(map(str,r)))

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

सीधा: उन अंकों को हटा दें जिन्हें पहले किसी विशिष्ट अक्षर द्वारा पहचाना जाता है।

Answer 10

पायथन 3 , 125 बाइट्स

lambda s:''.join(min(w)*(2*sum(map(s.count,w[:2]))-sum(map(s.count,w)))for w in"O1WU W2 H3G U4 F5U X6 S7X G8 IUFXG9".split())

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

लिंक की गई चुनौती को पढ़ने के बाद मैंने महसूस किया कि यह mdahmoune के पाइथन समाधान पर एक भिन्नता है , जो खुद ड्रेको 18 के ईएस 6 समाधान पर आधारित है , लेकिन हे, कम से कम हम दो बाइट से दूर हो गए।

उस समाधान की तरह, हम कुछ अक्षरों की घटनाओं की संख्या के रैखिक संयोजन के माध्यम से उत्तर की गणना करते हैं। हम रैखिक संयोजनों को संक्षेप में शब्दों के रूप में लिखकर सांकेतिक शब्दों में बदलना करते हैं जहां पहले दो अक्षर जोड़े जाने हैं और बाद में सब कुछ घटाया जाना है। कभी-कभी पहले दो पात्रों को पैड करने के लिए एक चरित्र की आवश्यकता होती है; हम इसका उपयोग उन अंकों को छिपाने के लिए करते हैं जिन्हें हम आउटपुट करना चाहते हैं (जो इनपुट में कभी नहीं होगा, इसलिए हमारे एल्गोरिदम को प्रभावित नहीं करेगा), जिसे हम साथ निकालते हैं min।

Answer 11

आर, 154

u=utf8ToInt(s)-71
m=sum
b=m(u==16)
d=m(u==14)
f=m(u==17)
a=m(u==8)-b-d
g=m(u==12)-f
cat(rep(1:9,c(a,b,m(u==11)-d,d,m(u==15)-g,f,g,m(!u),(m(u==7)-a-g)/2)))

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

Answer 12

Axiom, 351 बाइट्स

s:="GXUWRFVIONETHS";e:EqTable(CHAR,INT):=table();v:=[8,6,4,2,3,5,7,9,1];z:=[k for k in 1..46|prime?(k)];F(x,y)==>for i in 1..#x repeat y;F(z,e.(s.i):=z.i);t:=[1787026,2451,16445,5957,16036207,130169,20372239,495349,20677];h(a)==(r:=1;F(a,r:=r*e.(a.i));j:=[];F(v,while r rem z.i=0 repeat(r:=r quo t.i;j:=cons(v.i,j)));j:=sort j;k:=0;F(j,k:=k*10+j.i);k)

असमतल टिप्पणी के परिणाम

s:="GXUWRFVIONETHS" -- tutte le lettere di ONE..NINE in ordine di importanza 
e:EqTable(Character,Integer):=table()
v:=[8,6,4,2,3,5,7,9,1]              -- numeri da controllare in quell'ordine di apparizione di v
z:=[k for k in 1..46|prime?(k)]     -- 14 numeri primi da associare a s
F(x,y)==>for i in 1..#x repeat y 
F(z,e.(s.i):=z.i)                   -- riempie la tavola associando numeri primi alle lettere "GXUW..."
t:=[1787026,2451,16445,5957,16036207,130169,20372239,495349,20677]  -- prodotto di numeri primi 1787026 dovrebbe essere HEIGHT
h(a)==
     r:=1 ;F(a,r:=r*e.(a.i))        -- calcola il numero associato alla stringa a
     j:=[];F(v,while r rem z.i=0 repeat(r:=r quo t.i;j:=cons(v.i,j)));j:=sort j  -- leva il nome dei numeri che man mano trova, aggiunge a j
     k:=0 ;F(j,k:=k*10+j.i)         -- costruisce il numero decimale k, da j vettore ordinato
     k                              -- ritorna tale numero k
------------------------------------------------------
(8) -> h("IHNEVGENNEISTE")
   (8)  789
                                                    Type: PositiveInteger