मूल संख्या

Question

दिशा-निर्देश

परिदृश्य

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

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

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

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

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

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

---

कार्य

एन्क्रिप्ट किए गए स्ट्रिंग 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

"ENOWOT" -> 12

"EONOTWHTERE" -> 123

"SNVEEGHEITNEIN" -> 789

"ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN" -> 123456789

"NOEWOTTOWHEERT" -> 1223

Comments

सभी परीक्षण मामलों में, केवल एक शब्द के भीतर अक्षरों को बदल दिया जाता है, शब्दों के बीच पत्र नहीं। क्या हमेशा ऐसा ही होगा?

— xnor

@xnor हमेशा ऐसा ही रहेगा। मैंने प्रश्न संपादित किया है।

— अमोरिस

फिर आपको इसे बदलने की जरूरत है ".... (यानी।" ONETWOTHREE "->" TTONWOHREEE ")"

— J42161217

@ TessellatingHeckler: एक गैर-सख्ती से बढ़ने वाला क्रम तब होता है जब अगला नंबर पिछले पूर्व के समान हो सकता है। 1-1-1-2-2-3 (गैर-सख्ती से बढ़ती) 1-2-3-4-5 (सख्ती से बढ़ती) के विपरीत

— koita_pisw_sou

तकनीकी रूप से, यह एन्कोडिंग है, एन्क्रिप्शन नहीं, क्योंकि कोई कुंजी नहीं है।

— पैट्रिक रॉबर्ट्स

Answer 1

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

ḟ“RGS”O“OX‘,“¢©“¢¢¤‘yF×4/%74ị⁽Gל?9¤Ḍ

पात्रों की एक सूची (स्ट्रिंग) और एक पूर्णांक लौटाता हुआ एक विचित्र लिंक।

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

Pietu1998 के जेली उत्तर के लिए एक बहुत ही अलग तरीके का उपयोग करता है , फिर भी एक ही बाइट गिनती है ( मुझे वास्तव में लगा कि शायद यह कम हो गया था )!

मूल संख्या ( HTREEWTONOEउदाहरण के लिए काम करने का एक इनपुट ) की एकरसता पर निर्भर नहीं करता है ।

कैसे?

पहले ध्यान दें कि शब्द खुद (और इसलिए किसी भी एनाग्रम्स) सभी को किसी भी रुपये, जीएस और एसएस को हटाकर किसी भी ओएस को दो वर्णों (जैसे "12") और तीन वर्णों वाले किसी भी एक्स के साथ बदल दिया जा सकता है। "345" कहो)।

letters  -> -RGS  -> O:12, X:345
ONE         ONE      12NE
TWO         TWO      TW12
THREE       THEE     THEE
FOUR        FOU      F12U
FIVE        FIVE     FIVE
SIX         IX       I345
SEVEN       EVEN     EVEN
EIGHT       EIHT     EIHT
NINE        NINE     NINE

इसके बाद हम अपनी पसंद ("12345") के आधार पर मोडुलो अंकगणितीय का उपयोग करते हुए उन वर्णों के अध्यादेशों के क्रमांक 1 से 9 की संख्या तक का नक्शा बना सकते हैं, फिर इन्हें अंकों की पुन: क्रमबद्ध सूची में देखें। कोड वास्तव में पहले वर्णों में आता है और फिर अध्यादेशों को बदल देता है, लेकिन यह 37 बाइट्स वर्णों के साथ संभव है, जैसे "DIAAE" ( इसे आज़माएं )।

ḟ“RGS”O“OX‘,“¢©“¢¢¤‘yF×4/%74ị⁽Gל?9¤Ḍ - link: list of characters
 “RGS”                                - literal ['R','G','S']
ḟ                                     - filter discard
      O                               - convert to ordinals
       “OX‘                           - code-page indices list = [79,88]
            “¢©“¢¢¤‘                  - code-page indices lists = [[1,6],[1,1,3]]
           ,                          - pair -> [[79,88],[[1,6],[1,1,3]]]
                    y                 - translate (replace 79s (Os) with [1,6]
                                                       and 88s (Xs) with [1,1,3])
                     F                - flatten into a single list
                       4/             - 4-wise reduce by:
                      ×               -   multiplication (product of each window of four)
                         %74          - modulo 74
                                   ¤  - nilad followed by link(s) as a nilad:
                             ⁽G×      -   base 250 literal = 18768
                                œ?9   -   permutation of [1,2,3,4,5,6,7,8,9] at that
                                      -   index in a lexicographically sorted list of
                                      -   all such permutations -> [1,5,8,2,4,9,7,6,3]
                            ị         - index into
                                    Ḍ - convert from decimal digits to an integer

Comments

आपका जवाब सचमुच इस पेज के लिए एक सही मान देता है पर केवल जवाब है: NINEONENIENOENNNIENOENNEINEONEINEONNENIENOINNEINENINNEINENIENNIENNNNIENNEININENIENNENINEINENINENNIEINNEINNENNIENIN।

— मैजिक ऑक्टोपस Urn

+ इन्फिनिटी अंक।

— मैजिक ऑक्टोपस Urn

धन्यवाद! ( मुझे फेंक दिया क्योंकि टिप्पणी में कोड ब्लॉक करने के लिए शून्य चौड़ाई रिक्त स्थान हैं, लेकिन (whew) यह काम करता है )

— जोनाथन एलन

यह वैसे भी एक वैध इनपुट नहीं है;)।

— मैजिक ऑक्टोपस Urn

अरे वाह, मुझे नहीं पता था कि एक इनाम आ रहा है - धन्यवाद! हाँ, यह अनुरोधित युक्ति का हिस्सा नहीं था, मैंने अभी एक तरीका बनाया है जो बिना इनपुट के काम करेगा।

— जोनाथन एलन

Answer 2

पायथन 2, 121 117 115 बाइट्स

def g(s,a=0,f=''):
 for c in s:
    a+=34**ord(c)%43;r='P!\x83u\x8eI\x92|Z'.find(chr(a))+1
    if r:f,a=f+`r`,0
 return f

-4 बाइट्स: सब के बाद कि मैं गोल्फ एक एकल चर चर इनलाइन भूल गया। दिमाग़ का दही।
-2 बाइट्स: डबल-स्पेंट इंडेंट → सिंगल टैब इंडेंट (कोटि जॉनाथन सक्समैन के लिए धन्यवाद); ध्यान दें कि यह उत्तर में सही ढंग से प्रदर्शित नहीं होता है।

Ungolfed (अजगर 3 के साथ संगत):

nums = [80, 33, 131, 117, 142, 73, 146, 124, 90]

def decode(str):
    acc = 0
    final = ''
    for c in str:
        acc += (34**ord(c))%43
        if acc in nums:
            final += str(1+nums.index(acc))
            acc=0
    return final

जादू नंबर खोजक:

#!/usr/bin/env python3
from itertools import count, permutations

def cumul(x):
    s = 0
    for v in x:
        s += v
        yield s

all_words = 'ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split()

for modulo in range(1, 1000):
    for power in range(1, 300):
        combinations = []
        for word in all_words:
            my_combination = []
            for perm in permutations(word):
                my_combination += cumul(power**(ord(x)) % modulo for x in perm)
            combinations.append(my_combination)

        past_combinations = set(())
        past_intermediates = set(())
        collision = False
        for combination in combinations:
            final = combination[-1]
            if final in past_intermediates or any(intermediate in past_combinations for intermediate in combination):
                collision = True
                break
            past_combinations.add(final)
            past_intermediates.update(combination)

        if not collision:
            print("Good params:", power, modulo)
            print("Results:", ", ".join(str(x[-1]) for x in combinations))

स्पष्टीकरण:

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

मैंने मल्टीप्लायर के वेरिएबल को पावर को प्रभावित करने वाले वैरिएबल में बदलना शुरू कर दिया क्योंकि (ट्रायल और एरर से) जो किसी तरह मुझे थोड़े छोटे गोल्फ वाले जवाब देने में कामयाब रहा।

और ऊपर आप उस ब्रूट-फोर्सिंग और थोड़ा मैनुअल गोल्फिंग के परिणाम देखते हैं।

3**xमूल रूप से चुनने का कारण यह है कि मुझे पता था कि आप वहां हर नंबर का प्रतिनिधित्व कर सकते हैं। किसी भी संख्या में सबसे अधिक दोहराया गया अंक दो (थ्रीई, sEvEn, NiNe, आदि) है, इसलिए मैंने हर इनपुट को आधार -3 नंबर के रूप में सोचने का फैसला किया। इस तरह मैं कर सकता है (मानसिक रूप से) उनकी तरह कुछ के रूप में प्रतिनिधित्व करते हैं 10100000000010020000(तीन; में एक 1 tस्लॉट, में एक 1 rस्लॉट, में एक 1 hस्लॉट, और में एक 2 eस्लॉट)। इस तरह से प्रत्येक संख्या को एक विशिष्ट प्रतिनिधित्व मिलता है जिसे आसानी से स्ट्रिंग को पुनरावृत्त करके और कुछ संख्याओं को जोड़कर आसानी से pieced किया जा सकता है, और यह अक्षरों के वास्तविक क्रम से स्वतंत्र समाप्त हो जाता है। बेशक, यह आदर्श समाधान नहीं निकला, लेकिन वर्तमान समाधान अभी भी इस विचार को ध्यान में रखकर लिखा गया है।

Comments

Py3K क्या है? ...

— कैलकुलेटर

माफी, संपादित (यह अजगर 3 का पूर्व नाम है)

— स्कोर_उंडर

यह सस्ता है, लेकिन आप एक ही टैब के लिए अपने दूसरे इंडेंटेशन स्तर (दो रिक्त स्थान) को दबाकर 2 बाइट्स (क्योंकि यह अजगर 2 है) बचा सकते हैं। [ tio.run/##NU7NCoJAGDy7T/… इसे ऑनलाइन आज़माएं!]

— Coty Johnathan Saxman

इसके अलावा, आप 6 शाब्दिक का उपयोग कर बाइट्स को बचाने के लिए सक्षम हो सकता है \x83, \x8eऔर \x92स्ट्रिंग में।

— कैलक्यूलेटरफ्लेन

@CalculatorFeline दुर्भाग्य से मेरे दुभाषिया ऐसा नहीं है SyntaxError: Non-ASCII character '\xc2' in file <stdin> on line 3, but no encoding declared; see http://python.org/dev/peps/pep-0263/ for details:। यह काम करता है अगर मैं codingटिप्पणी को वहाँ रखा , लेकिन वह 15 अतिरिक्त बाइट्स प्राप्त करता है।

— स्कोर_उंडर

Answer 3

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

s=input()
for y in'WXGURFSOIZ':vars()[y]=s.count(y)
while Z<9:s+=[O-U-W,W,R-U,U,F-U,X,S-X,G,I-X-G-F+U][Z]*str(Z+1);Z+=1
print s

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

जावास्क्रिप्ट Draco18s समाधान के एक सही संस्करण पर आधारित है ।

Comments

का एक दिलचस्प उपयोग क्या है vars!

— Xnor

@xnor यह अंडा था कि मुझे कैसे पता चला कि अन्य गोल्फों के लिए :)))

— mdahmoune

बहुत चालाक। मेरे उत्तर को स्वीकार करने के लिए +1 करें (जैसा कि मूल रूप से त्रुटिपूर्ण था)।

— ड्रेक 18s

Answer 4

PHP , 164 बाइट्स

for($c=count_chars($argn);$i<9;)echo str_pad("",[$c[79]-$c[87]-$u=$c[85],$c[87],$c[72]-$g=$c[71],$u,$f=$c[70]-$u,$x=$c[88],$c[86]-$f,$g,$c[73]-$x-$f-$g][+$i],++$i);

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

PHP , 179 बाइट्स

पिछले दृष्टिकोण के आधार पर पहले संख्याओं की जाँच करें और फिर बढ़ते क्रम में विषम संख्याओं की जाँच करें

for($z=[$o=($c=count_chars($argn))[87],$f=$c[85],$x=$c[88],$g=$c[71],$c[79]-$o-$f,$c[72]-$g,$v=$c[70]-$f,$c[86]-$v,$c[73]-$x-$v-$g];$i<9;)echo str_repeat(++$i,$z[_405162738[$i]]);

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

PHP , 201 बाइट्स

for(;$o=ord(WUXGOHFVN[$i]);$i++)for(;$r[$o]<count_chars($argn)[$o];$t[]=$i>3?2*$i-7:2+2*$i,sort($t))for(++$r[$o],$n=0;$q=ord(([TO,ORF,IS,HEIT,EN,TREE,IVE,SEEN,NIE][+$i])[$n++]);)$r[$q]++;echo join($t);

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

Comments

के लिए विफल रहता हैENOOWTWTOWOT

— टाइटस

@ टिट्स अब तय हो गया है। मैंने इस प्रश्न को गलत समझा है

— Jörg Hülsermann

हाँ उदाहरण कुछ भ्रामक हैं। वाह क्या खर्चा हुआ! क्या आप इसे तोड़ देंगे ?!

— टाइटस

@Titus मुझे लगता है कि मैं अपने दृष्टिकोण के रूप में एक और तरीका खोजने के लिए सीमा तक पहुँच है

— Jörg Hülsermann

$i++<9और $iके बजाय $i<10और ++$i(-1 बाइट); _405162738[$i]के बजाय $i%2?$i/2+4:$i/2-1(-4 बाइट्स) ( $i/2+~($i%2*-5)यह भी काम करेगा, लेकिन एक बाइट अधिक लंबा है।)

— टाइटस

Answer 5

जावास्क्रिप्ट (ईएस 6), 288 150 144 बाइट्स

q=s=>[u=(l=t=>s.split(t).length-1)`U`,l`O`-l`W`-u,l`W`,l`R`-w,u,f=l`F`-u,x=l`X`,l`S`-x,g=l`G`,l`I`-x-g-f].map((n,i)=>`${i}`.repeat(i&&n)).join``

const testCases = ['NEO', 'ENOWOT', 'EONOTWHTERE', 'SNVEEGHEITNEIN', 'ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN']

testCases.forEach(testCase => console.log(testCase, q(testCase)))

अन्य दो जेएस प्रविष्टियों में से एक की तुलना में लंबा है , लेकिन मुझे लगा कि मैं एक दिलचस्प दृष्टिकोण छोड़ दूंगा जो किसी अन्य भाषा में किसी के लिए काम कर सकता है।

अनिवार्य रूप से हम निम्नलिखित निर्धारित कर सकते हैं:

W -> 2
X -> 6
G -> 8
U -> 4

इन अक्षरों की कोई भी घटना का अर्थ है कि वह अंक मूल संख्या में मौजूद है। यहाँ से हम बाकी अंकों को घटा सकते हैं:

R-U -> 3
F-U -> 5
S-X -> 7

दो जटिल मामलों सहित:

O-(U+W) -> 1
I-(X+G+(F-U)) -> 9

दोनों 1और 9क्षेत्र तुलनात्मक रूप से कठिन। एक के लिए, Eकुछ शब्दों में एक से अधिक बार दिखाता है ( SEVENदो है) जैसा कि करता है N( NINE), इसलिए हम जांच के लिए फंस गए हैंO जिसके दो अन्य स्थानों पर होता है, सौभाग्य से दोनों सरल हैं।

नौ के लिए, नौ कठिन है, चाहे आप इसे कैसे भी काट लें।

इस प्रकार हम इस नक्शे को समाप्त करते हैं:

[u=(l=t=>s.split(t).length-1)`U`,  //unused 0; precompute 'U's
 l`O`-l`W`-u,    //1
 l`W`,           //2
 l`R`-w,         //3
 u,              //4
 f=l`F`-u,       //5
 x=l`X`,         //6
 l`S`-x,         //7
 g=l`G`,         //8
 l`I`-x-g-f]     //9

9 बाइट्स को बचाते हुए, चर असाइनमेंट के साथ siX, eiGht, और फाइव (5 बैक-रेफरेंसिंग फुहार के साथ) को रेफर करने में सक्षम है। इसके लिए नील को धन्यवाद, यह जेएस की कई विशेषताओं का उपयोग करता है मैं बहुत अपरिचित हूं ( ('उदाहरण के लिए, आधे में स्ट्रिपिंग के लिए बैक-टिक्स ), और वास्तव में यह विचार के बहुत करीब आता है कि मैं इसे कोड करने का प्रयास करने से पहले कागज़ पर आउट कर दूंगा। (मैं के रूप में "क्या ऐसा शेष" 9 को छोड़ दिया था, इस बारे में सोच के रूप में "अगर मैं एक को देखने Xमैं इसे हटा सकते हैं और एक Sऔर Iस्ट्रिंग से है, तो ..." इतना है कि चार साधारण मामलों के बाद अगले 3 होगा बन सरल)।

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

q=s=>[u=(l=t=>s.split(t).length-1)`U`,l`O`-l`W`-u,l`W`,l`R`-w,u,f=l`F`-u,x=l`X`,l`S`-x,g=l`G`,l`I`-x-g-f].map((n,i)=>`${i}`.repeat(i&&n)).join``

const testCases = ['XENSENINEVSI']

testCases.forEach(testCase => console.log(testCase, q(testCase)))

Comments

ग्रेट, लेकिन 9 की गिनती के साथ एक समस्या है ... मुझे लगता है कि यह ixg-f + u

— mdahmoune

@mdahmoune गोली मारो, तुम सही हो। मैंने वह गड़बड़ कर दी। : <

— ड्रेको १

4 बाइट्स का उपयोग करके सहेजें s.split(t).length-1, 2 बाइट्स का उपयोग करके s.repeat(n>0&&n)(क्यों वैसे भी शून्य से कम है? 7 बाइट्स बचाता है)। बाइट्स के एक झुंड को gइस दायरे में घोषित करके बचाएं sकि आपको इसे हर समय पास नहीं रखना है, और बेहतर है कि आप इसे एक टैग किया हुआ टेम्पलेट बना सकें, जो कुल मिलाकर 55 बाइट्स बचाता है (9 सुधार से पहले)। सहेजें अधिक temporaries में दोहराया मूल्यों को सहेज कर बाइट्स, और मैं का उपयोग कर बंद कुछ और मुंडा map: s=>[,(l=t=>s.split(t).length-1)`O`-l`W`-l`U`,w=l`W`,l`R`-w,u=l`U`,l`F`-u,x=l`X`,l`S`-x,g=l`G`,l`I`-x-g].map((n,i)=>`${i}`.repeat(n)).join`` ।

— नील

@ नहीं मुझे यकीन नहीं है कि एन कभी शून्य से कम क्यों समाप्त हुआ, लेकिन यह तीन के लिए परीक्षण करते समय किया गया था। मैं एक त्रुटि प्राप्त करता रहा और जाँच करता रहा कि मुझे इसकी आवश्यकता है, लेकिन मुझे अभी भी यकीन नहीं है। आपके द्वारा प्राप्त किया गया टेम्प्लेटेड लाइब्रेरी का नक्शा जावास्क्रिप्ट है जिसे मैं पढ़ना भी नहीं जानता। : डी

— ड्रेको १

@Neil आह, ठीक है, n की जाँच के लिए कारण> 0: अगर है एक दो लेकिन कोई तीन। आर = 0, डब्ल्यू = 1. 0-1 = -1। मुझे यह पता लगाने में समस्या हो रही थी कि एक घंटे पहले, मुझे पता था कि यह 3-चेक से संबंधित था, लेकिन एक समय का शैतान था जो इसे काम कर रहा था (कॉफी की कमी)।

— ड्रेको 18s

Answer 6

गणितज्ञ, 133 बाइट्स

(s={};c=Characters;j=c@#;Table[If[FreeQ[j~Count~#&/@c[#[[i]]]&@ToUpperCase@IntegerName@Range@9,0],s~AppendTo~i],{i,9}];FromDigits@s)&

इनपुट

"VENESGTHIEENNI"

उत्पादन

789

Comments

आप के c@#[[i]]बजाय के साथ एक अतिरिक्त बाइट बचा सकता है c[#[[i]]]? आप इन्फ़िक्स वाक्य रचना का उपयोग करके एक और बाइट को बचाने के लिए सक्षम हो सकता है ~पर Table।

— नंबरमान

Answer 7

सी #, 218 बाइट्स

लघु संस्करण:

string q(string s){var n="ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE".Split(',');for(inti=0,j;;i++)for(j=0;n[i].IndexOf(s[j])>=0;){if(++j==n[i].Length){var r=++i+"";for(;j<s.Length;r+=++i)j+=n[i].Length;return r;}}}

विस्तारित संस्करण:

string q(string s)
{
    var n = "ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE".Split(',');
    for (int i = 0, j; ; i++)
        for (j = 0; n[i].IndexOf(s[j]) >= 0;)
        {
            if (++j == n[i].Length)
            {
                var r = ++i + "";
                for (; j < s.Length; r += ++i)
                    j += n[i].Length;
                return r;
            }
        }
}

ऑनलाइन प्रयास करें!

मेरी पहली प्रविष्टि होने के नाते, मैं नियमों के बारे में अनिश्चित हूं ... मैं केवल उस श्रेणी का आकार गिन रहा हूं जिसका उपयोग डे-क्रिप्ट के लिए किया गया है, न कि उस कोड का परीक्षण करता है जो सही है?

संपादित करें

और इसके मज़े के लिए - यहाँ मैंने क्या करना शुरू किया, पूरा नियम नहीं पढ़ा: S - इसे IdeOne पर देखें । यह तब भी होता है जब एक अंक के अक्षर स्ट्रिंग में किसी भी स्थान पर जा सकते हैं।

संपादित करें 2

TheLethalCoder द्वारा युक्तियों के अनुसार छोटा किया गया। धन्यवाद!

संपादित करें 3

और अब टाइटस ने कुछ और बाइट्स का मुंडन किया। धन्यवाद!

Comments

नमस्कार और PPCG में आपका स्वागत है! आपको केवल विधि को शामिल करने की आवश्यकता है, आप public staticइसे से निकाल सकते हैं । आप जैसे अनाम विधि में परिवर्तित कर सकते हैं s=>{<do stuff>return"";}। आप varकुछ बार उपयोग कर सकते हैं , साथ में चर घोषित करके बाइट्स बचाता है int i=1,j;। स्ट्रिंग से एक सरणी बनाना और उस पर विभाजित करना आमतौर पर कम होता है (हालांकि मैंने इस मामले में जाँच नहीं की है) "ONE|TWO".Split('|')। आप <0इसके बजाय==-1

— TheLethalCoder

अधिक सुझावों के लिए C # में कोड-गोल्फिंग के लिए टिप्स देखें ।

— TheLethalCoder

@LethalCoder महान सुझाव, धन्यवाद!

— समवन जू

बिल्कुल भी परीक्षण नहीं किया गया है, लेकिन मेरा मानना ​​है कि निम्नलिखित 221 बाइट्स के लिए आपके कोड के बराबर है:s=>{var n="ONE|TWO|THREE|FOUR|FIVE|SIX|SEVEN|EIGHT|NINE".Split('|');for(int i=0,j;++i<= 9;)for(j=0;n[i-1].IndexOf(s[j])<0;){if(++j==n[i-1].Length){var r=i+"";while(j<s.Length){j+=n[i].Length;r+=++i;}return r;}}return "";}

— TheLethalCoder

एक तरफ ध्यान दें पर यह आम तौर पर उपयोग करने के लिए आसान है TIO अपने TIO के लिए!

— TheLethalCoder

Answer 8

जावास्क्रिप्ट (ईएस 6), 142 139 बाइट्स

बची हुई 3 बाइट्स नील की बदौलत ।

वर्तमान में संख्या का लाभ नहीं उठाता हमेशा आरोही क्रम में व्यवस्थित किया जाता है

f=s=>s?'ENO|OTW|EEHRT|FORU|EFIV|ISX|EENSV|EGHIT|EINN'.split`|`.findIndex(w=>[...s.slice(0,y=w.length)].sort().join``==w)+1+f(s.slice(y)):''

f=s=>s?'ENO|OTW|EEHRT|FORU|EFIV|ISX|EENSV|EGHIT|EINN'.split`|`.findIndex(w=>[...s.slice(0,y=w.length)].sort().join``==w)+1+f(s.slice(y)):''

const testCases = ['NEO', 'ENOWOT', 'EONOTWHTERE', 'SNVEEGHEITNEIN', 'ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN']

testCases.forEach(testCase => console.log(testCase, f(testCase)))

Comments

रुको क्या?? "axbxc".split`x`.join``। इसे कैसे कहा जाता है? लगता है कि Google पर कुछ भी नहीं मिल रहा है।

— क्वर्टी

@ क्वर्टी - उन्हें टेम्प्लेट शाब्दिक टैग किया जाता है , एक ईएस 6 फीचर जो मैं कुछ बाइट्स को बचाने के लिए उपयोग कर रहा हूं, जो कि मामले में पैरेंस की आवश्यकता नहीं है splitऔरjoin

— क्रेग आयेर

आपने इसका उत्तर दिया। मुझे पता है कि टेम्प्लेट शाब्दिक हैं, लेकिन मुझे नहीं पता है कि आप इन कार्यों पर भी इसका उपयोग कर सकते हैं। धन्यवाद।

— क्वर्टी

वे थोड़े अलग हैं, आपके पास टेम्पलेट शाब्दिक (जैसे x=`foo${5+5}bar`) हैं, उन्हें टैग किया जाता है जब आप किसी फ़ंक्शन को बिना परेंस के उपयोग करते हुए कहते हैं: foo`foo${5+5}bar`जो कि उसी तरह हैfoo(['foo','bar'], 10)

— क्रेग आयरे

f(s.slice(y))हमेशा एक स्ट्रिंग है ताकि आपको ''+इससे पहले इसकी आवश्यकता न हो।

— नील

Answer 9

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

Dị“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»Ḳ¤FṢŒu
L3*Ç€iṢ

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

व्याख्या

L3*Ç€iṢ    Main link. Argument: s (string)
L            Get length of s.
 3*          Raise 3 to that power. This will always be greater than n.
   ǀ        Get the name of each of the numbers using the helper link.
     iṢ      Find the position of the sorted input.

Dị“©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»Ḳ¤FṢŒu    Helper link. Argument: n (number)
D                                   Get digits of n.
  “©ȯ¿w¶&ÇhṆỌƘ#Ȯʋ~¢CNẓ_»            The string "one two (...) eight nine AA".
                        Ḳ           Split that string at spaces.
 ị                                  Get name of each digit in the list.
                          F         Flatten to a single string.
                           Ṣ        Sort the characters.
                            Œu      Make uppercase.

Comments

आपके कोड के साथ कोई समस्या है। इसमें स्ट्रिंग पास करने की कोशिश करें "EIGHTNINE":)

— एमोरिस

@ मॉरिस 0 बाइट्स के लिए तय किया गया।

— पुरकाकूदरी

मुझे लगता है कि यह "VENESGTHIEENNI" के लिए काम नहीं करता है

— J42161217

मैं दूसरा @ जेनी_मैथी

— एमोरिस

@ जेनी_मैथी कार्यक्रम बहुत ही अक्षम है और लंबे इनपुट्स के लिए समय और स्मृति से बाहर है (मुझे पता है, यह वास्तव में बुरा है)। आप बदल सकते हैं 3के साथ 2.2एक छोटे ऊपरी बाध्य है, जो आप आसानी से काम कर रहे सिद्धांत को बदले बिना 789 गणना करने के लिए अनुमति देता है का उपयोग करें। 2अच्छा होगा, लेकिन यह छक्के के साथ कुछ इनपुट के लिए मुश्किल से विफल होगा।

— पुरकाकूदरी

Answer 10

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

s=>(m=btoa`8Ñ>Mc¾LtDáNQ!Q>HþHA7átþ4Ò`.split`+`.map(s=>RegExp(s.replace(/(.)\1*/g,c=>`(?=(.*${c[0]}){${c.length}})`))),t=0,r=0,[...s].map(c=>(t+=c,d=1,n=0,m.map((r,i)=>t.match(r)&&(d--,n=i)),d||(r=r*10+n+1,t=0))),r)

उदाहरण कोड स्निपेट:

f=

s=>(m=btoa`8Ñ>Mc¾LtDáNQ…!Q>H…þHA7átþ4Ò`.split`+`.map(s=>RegExp(s.replace(/(.)\1*/g,c=>`(?=(.*${c[0]}){${c.length}})`))),t=0,r=0,[...s].map(c=>(t+=c,d=1,n=0,m.map((r,i)=>t.match(r)&&(d--,n=i)),d||(r=r*10+n+1,t=0))),r)

console.log(f("NEO"))
console.log(f("ENOWOT"))
console.log(f("EONOTWHTERE"))
console.log(f("SNVEEGHEITNEIN"))
console.log(f("ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN"))

Answer 11

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

([ONE]{3})*([TWO]{3})*([THRE]{5})*([FOUR]{4})*([FIVE]{4})*([SIX]{3})*([SEVN]{5})*([EIGHT]{5})*([NIE]{4})*
$#1$*1$#2$*2$#3$*3$#4$*4$#5$*5$#6$*6$#7$*7$#8$*8$#9$*9

इसे ऑनलाइन आज़माएं! @ TessellatingHeckler के पॉवरशेल जवाब पर आधारित है।

Answer 12

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

[EFIST]

^(ON|NO)*
$#1$*1
O

W
2
HR|RH
3
UR|RU
4
X
6
GH|HG
8
(NN)*$
$#1$*9
r`NV|VN
7
V
5

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

व्याख्या

• सबसे पहले, विशिष्टता के लिए आवश्यक अनावश्यक वर्णों का एक समूह छोड़ दें
• 1s को सामने से चुनें (इससे हमें बाकी के ओएस को तुरंत छोड़ देना चाहिए और 5, 7, 9 मेस में आने से पहले कुछ एनएस को साफ़ करना होगा)
• 2, 3, 4, 6 और 8 अब तुच्छ हैं
• 9s एक डबल एनएन हैं, इसलिए 5 और 7 से निपटने से पहले हम इसे समाप्त कर लेते हैं
• 7s को दाईं ओर से बदलें (ताकि हम VNV को 57 के बजाय 75 तक कम न करें)
• 5 एस शेष बनाम हैं

Comments

यदि आप शीर्षलेख में% (G`) जोड़ते हैं, तो आप मूल कोड का उपयोग कर सकते हैं और यह इनपुट की प्रत्येक पंक्ति का अलग से मूल्यांकन करेगा: TIO

— PunPun1000

धन्यवाद @ PunPun1000 मुझे लगा कि ऐसा करने का एक तरीका होना चाहिए, लेकिन जल्दी नहीं मिलने के बाद छोड़ दिया।

— क्यूर्टन

Answer 13

पॉवरशेल , 182 बाइट्स

[regex]::Replace("$args",'(?<1>[ONE]{3z2>[TWO]{3z3>[THRE]{5z4>[FOUR]{4z5>[FIVE]{4z6>[SIX]{3z7>[SVEN]{5z8>[EIGHT]{5z9>[NIE]{4})'.replace('z','})|(?<'),{$args.groups.captures[1].name})

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

Ungolfed लेकिन काम कोड नहीं:

[System.Text.RegularExpressions.Regex]::Replace("$args",

    '(?<1>[ONE]{3})       
    |(?<2>[TWO]{3})
    |(?<3>[THRE]{5})
    |(?<4>[FOUR]{4})
    |(?<5>[FIVE]{4})
    |(?<6>[SIX]{3})
    |(?<7>[SVEN]{5})
    |(?<8>[EIGHT]{5})
    |(?<9>[NIE]{4})'

    ,{$args.groups.captures[1].name}
)

जैसे (?<3>[THRE]{5})चरित्र वर्ग से मेल खाता हैTHRE , इसलिए यह उन्हें क्रम से बाहर कर सकता है, और इनमें से किसी भी वर्ण को एक दूसरे के बगल में पांच बार मेल खाना है, और कैप्चर समूह का नाम संख्याओं के साथ मैप करने के लिए '3' है।

})|(?<एक के लिए दोहराए गए पाठ को स्वैप करके रुडिमेंट्री संपीड़न z।

Answer 14

सी ++, 296 , 288 बाइट्स

लघु संस्करण:

#define T string
using namespace std;T N[]={"ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE"};T Q(T S){T R="";for(int i=0;i<9;i++){do{if(S.find(N[i])!=T::npos){S.erase(S.find(N[i]),N[i].size());R+=to_string(i+1);}}while(next_permutation(N[i].begin(),N[i].end()));}return R;}

पूर्ण संस्करण:

#define T string
using namespace std;

T N[]={"ONE","TWO","THREE","FOUR","FIVE","SIX","SEVEN","EIGHT","NINE"};

T Q(T S)
{
    T R="";
    for(int i=0;i<9;i++)                             //for all possible                             
                                                     //codewords (ONE,TWO...NINE)   
    {
        do
        {   
            if(S.find(N[i])!=T::npos)                //if found in encrypted word
            {
                S.erase(S.find(N[i]),N[i].size());  //erase it from the word
                R+=to_string(i+1);                  //save integer to the result string
            }
                                                    //check next permuation of codeword  

        } while(next_permutation(N[i].begin(),N[i].end())); 
    }                                                   

    return R;
}

ऑनलाइन प्रयास करें!

संपादित करें:
1) 200-> 296 बाइट्स के लिए, नाम सहित और एन की परिभाषा गिनती में, जैसा कि orlp 2 द्वारा सुझाया गया है) 296-> 288, मैक्रो का उपयोग करने के लिए, Zacharý के लिए धन्यवाद

Comments

आपको अपनी बाइट गिनती में Nऔर उसकी परिभाषा को शामिल करना होगा using namespace std;।

— orlp

मुझे अधिक विशिष्ट होना चाहिए, न केवल इसे अपनी बाइट की गिनती में शामिल करना चाहिए, बल्कि आपके उत्तर में भी होना चाहिए। आपका उत्तर Qबिना किसी अन्य परिवर्धन के ठीक बाद कॉल करके चलाने में सक्षम होना चाहिए ।

— orlp

मैंने यह सब शामिल करने के लिए फिर से संपादन किया। एन की परिभाषा के लिए मुझे खुद पर यकीन नहीं था, लेकिन नेमस्पेस के लिए, मैं आमतौर पर इसे शामिल नहीं करता (इसे लाइब्रेरी के सामान के रूप में मानता हूं)। हालांकि, वर्तमान कोड में यह स्ट्रिंग के लिए काम करने के लिए महत्वपूर्ण है

— koita_pisw_sou

क्या आप कुछ बाइट्स को बचाने के लिए मैक्रो को परिभाषित कर सकते हैं? repl.it/JY7k

— Zacharý

Answer 15

रूबी, 138 114 110 बाइट्स

gsub(/#{"3ONE3TWO5THRE4FOUR4FIVE3SIX5SEVN5EIGHT4NIE".gsub(/(.)(\D+)/,'([\2]{\1})|')}/){(1..9).find{|i|$~[i]}}

बाइट काउंट में 1 बाइट शामिल है -p विकल्प के है।

क्या?

यह:

/#{"3ONE3TWO5THRE4FOUR4FIVE3SIX5SEVN5EIGHT4NIE".gsub(/(.)(\D+)/,'([\2]{\1})|')}/

एक रेगेक्स शाब्दिक है, जो स्ट्रिंग प्रक्षेप के माध्यम से मूल्यांकन करता है:

/([ONE]{3})|([TWO]{3})|([THRE]{5})|([FOUR]{4})|([FIVE]{4})|([SIX]{3})|([SEVN]{5})|([EIGHT]{5})|([NIE]{4})|/

यदि हम यह निर्दिष्ट करते हैं कि regex, शेष कोड को पकड़ना कुछ आसान है: इनपुट में प्रत्येक मैच को कैप्चरिंग समूह की संख्या के साथ प्रतिस्थापित किया जाता है, जिसे जादुई चर से निकाला जाता है $~जिसमें वर्तमान मिलान डेटा होता है:

gsub(regex){(1..9).find{|i|$~[i]}}

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

Answer 16

जावा 8, 198 256 बाइट्स

s->{String r="",x=r;for(String n:"ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE".split(" ")){for(char c:n.toCharArray())x+="(?=.*"+c+")";x+="["+n+"]{"+n.length()+"}x";}for(int i=0,q;i<9;)for(q=(s+" ").split(x.split("x")[i++]).length-1;q-->0;)r+=i;return r;}

+58 बाइट्स .. पिछले संस्करण के रीगेक्स के कारण ठीक से काम नहीं कर रहा है (यह "ईईई"; "ईईएन"; आदि) से भी मेल खा रहा है।

स्पष्टीकरण:

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

s->{                     // Method with String as parameter and return-type
  String r="",           //  Result-String
         x=r;            //  Regex-String
  for(String n:"ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE".split(" ")){
                         //  Loop (1) from "ONE" through "NINE":
    for(char c:n.toCharArray())
                         //   Inner loop (2) over the characters of this String
      x+="(?=.*"+c+")";  //    Append regex-group `(?=\w*c)` where `c` is the capital character
                         //   End of inner loop (2) (implicit / single-line body)
    x+="["+n+"]{"+n.length()+"}x";
                         //   Append regex part `[s]{n}` where `s` is the String, and `n` is the length
  }                      //  End of loop (1)
  // The regex now looks like this, which we can split on "x":
  // (?=.*O)(?=.*N)(?=.*E)[ONE]{3}x(?=.*T)(?=.*W)(?=.*O)[TWO]{3}x(?=.*T)(?=.*H)(?=.*R)(?=.*E)(?=.*E)[THREE]{5}x(?=.*F)(?=.*O)(?=.*U)(?=.*R)[FOUR]{4}x(?=.*F)(?=.*I)(?=.*V)(?=.*E)[FIVE]{4}x(?=.*S)(?=.*I)(?=.*X)[SIX]{3}x(?=.*S)(?=.*E)(?=.*V)(?=.*E)(?=.*N)[SEVEN]{5}x(?=.*E)(?=.*I)(?=.*G)(?=.*H)(?=.*T)[EIGHT]{5}x(?=.*N)(?=.*I)(?=.*N)(?=.*E)[NINE]{4}x
  for(int i=0,q;i<9;)    //  Loop (3) from 0 through 9 (exclusive)
    for(q=(s+" ").split(x.split("x")[i++]).length-1;
                         //   Split the input on the current regex-part,
                         //   and save the length - 1 in `q`
        q-->0;           //   Inner loop (4) over `q`
      r+=i               //    And append the result-String with the current index (+1)
    );                   //   End of inner loop (4)
                         //  End of loop (3) (implicit / single-line body)
  return r;              //  Return the result-String
}                        // End of method

Comments

Erf ... के लिए गलत परिणाम "ENOOWTEERHTRUOFEVIFXISNEVESTHGIEENIN":(

— ओलिवियर ग्रेजायर

हाँ, यह केवल एक चीज है जिसने मुझे +1 करने से रोका है! मेरा समाधान 240 बाइट्स का था ... इससे पहले कि आप मुझे हरा दें।

— ओलिवियर ग्रेजायर

@ OlivierGrégoire अपना 240 बाइट समाधान पोस्ट करने के लिए स्वतंत्र महसूस करें, क्योंकि मैं एक समाधान खोजने में असमर्थ हूं .. इसके बारे [ONE]{3}में नुकसान यह है कि यह EENउस परीक्षण मामले के अंत में आठ और नौ के हिस्सों के साथ भी मेल खाता है .. और मुझे इसमें संदेह है एक रेगुलर एक्सप्रेशन से मेल करने के लिए इन सभी: ENO|EON|NEO|NOE|OEN|ONEभी मिलान के बिना EEE;EEN;EEO;...के लिए सभी संख्या है कि कम से कम 40 बाइट्स .. शायद मैं का उपयोग कर कुछ कर सकते हैं substringऔर संख्या की जाँच रिवर्स, लेकिन मैं वास्तव में समय अब यह पता लगाने की जरूरत नहीं है ..

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

@ OlivierGrégoire यदि आपके पास अभी भी अपना 240 बाइट का उत्तर है, तो इसे पोस्ट करने के लिए स्वतंत्र महसूस करें। बस फिर से इस चुनौती के सामने आया, और +58 बाइट्स के लिए एक नया रेगेक्स बनाकर मेरा जवाब तय किया ..

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

ठीक है, ऐसा लगता है कि मैंने इस चुनौती को भुनाने के दौरान और भी छोटा रास्ता ढूंढा : p

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

Answer 17

जावा (ओपनजेडके 8) , 181 बाइट्स

s->{String x="",r;for(int i=0,l;i<9;)for(r="ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE".split(",")[i++],l=r.length();s.matches("["+r+"]{"+l+"}.*");s=s.substring(l))x+=i;return x;}

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

मैंने केविन क्रूसेन के TIO टेम्पलेट का पुन: उपयोग करने के लिए स्वतंत्रता ली । आशा है कि आप बुरा नहीं मानेंगे;)

Comments

आह, मेरी पिछली टिप्पणी पर कोई बात नहीं .. आप regex पर लूप के बजाय, regex का निर्माण करते हैं। फिर भी, मैं अपने पहले उत्तर के साथ पास था अगर केवल मैंने ही उपयोग किया होता s.substring। सबसे बुरी बात यह है, कि मैं s.substringअपने वर्तमान उत्तर में उपयोग कर रहा हूँ , lol .. आह अच्छी तरह से, +1 मुझसे। खुशी है कि यह लगभग सप्ताहांत है ..

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

Answer 18

05AB1E , 36 31 बाइट्स

‘€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘#vyœN>UvyX:

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

---

यह डिबग के साथ भाग गया देखें: TIO विथ डिबग

‘€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š‘# | Push ['ONE', 'TWO', 'THREE', 'FOUR', 'FIVE', 'SIX', 'SEVEN', 'EIGHT', 'NINE']
vyœ                   | For each list of permutations of that word...
   N>U                | Push index + 1 into register X.          
      vyX:            | Replace each permutation with X.

Comments

मैं सिर्फ सुझाव दे रहा था कि आपके पास मेरे बजाय हरे रंग का निशान था और मैंने एक बग पर ध्यान दिया: FURONESEVरिटर्न FUR1SEV:(

— जोनाथन एलन

Answer 19

पर्ल 5 , 102 + 1 (एन) = 103 बाइट्स

for$i(map{"[$_]{".length.'}'}ONE,TWO,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE){$,++;print$,while(s/^$i//)}

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

Comments

अच्छा! मदद करने वाले टोटकों की जोड़ी: map{...}अक्सर के साथ प्रतिस्थापित किया जा सकता है map...,, lengthऔर y///cआमतौर पर विनिमेय होता है (हमेशा छोटा नहीं होता है जब पर काम नहीं कर रहा है $_!), के बजाय while, ++$,x s/^$i//छोटा होता है, और यदि आप बदल -nजाते -pहैं तो आप इसके बजाय `$ 'के लिए अपील कर सकते हैं। कॉलिंग की print! इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

इसके अलावा, मुझे आशा है कि आप मुझे कोई सलाह पोस्ट करने से मना नहीं करेंगे, अगर आप चाहें तो मैं मना कर दूंगा। :)

— डोम हेस्टिंग्स

Answer 20

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

def f(s):
 e=''
 while len(s):
  for i in range(9):
   for r in[''.join(p)for p in permutations('ONE TWO THREE FOUR FIVE SIX SEVEN EIGHT NINE'.split()[i])]: 
    if s[:len(r)]==r:e+=str(i+1);s=s[len(r):]
 return e
from itertools import*

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

---

जानवर बल समाधान, अंकों की गैर-कमी का लाभ नहीं लेता है।

---

@Mr को धन्यवाद। 2 बाइट बचाने के लिए एक्सकोडर!

Comments

आपको def f(s):अपनी बाइट गिनती में शामिल करना होगा, यह एक अनाम फ़ंक्शन नहीं है

— श्री Xcoder

इसके अलावा आप के while len(s)>0साथ बदल सकते हैंwhile len(s)

— श्री Xcoder

@ श्री एक्सकोडर उस स्पष्टीकरण के लिए धन्यवाद

— चेस वोगेली

आप eफ़ंक्शन हेडर की घोषणा को -1 बाइट में स्थानांतरित कर सकते हैं । इसके अलावा, execऔर सूची की समझ भी इंडेंटेशन पर बाइट्स को बचा सकती है।

— कैलक्यूलेटरफुल

Answer 21

PHP, 141 बाइट्स

for($a=count_chars($argn);$c=ord($s[++$p]?:$s=[OWU,W,HG,U,FU,X,SX,G,N17.$p=0][$i-print str_repeat($i++,$x)]);)$x=$a[$i+48]+=($p?-1:1)*$a[$c];

पुराने संस्करण, 151 बाइट्स :

for($a=count_chars($argn,1);$s=[OWU,W,HG,U,FU,X,SX,G,N17][+$i++];print str_repeat($i,$a[$i+48]))for($p=0;$c=ord($s[$p]);)$a[$i+48]+=($p++?-1:1)*$a[$c];

1 से 9 तक अंकों के माध्यम से छोरों, शब्द में अद्वितीय वर्णों की गिनती और गैर-अद्वितीय वर्णों की संख्या को घटाते हुए, चलते-फिरते अंकों को छापते हैं।
हालाँकि यह चलते-फिरते मुद्रण कर रहा है, लेकिन अंकों की गणना के लिए संग्रहित किया जाना चाहिए9 मामले में काम करने के ।

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

यह डिजिट काउंट को स्टोर करने के लिए 4 और बाइट को सेव करने के $a[$i]बजाय $a[$i+48]ASCII 1और 7(कोट्स में) डिजिट कैरेक्टर्स के बजाय खुद इस्तेमाल करेगा।

टूट - फूट

for(
    $a=count_chars($argn,1);                # count character occurences in input
    $s=[OWU,W,HG,U,FU,X,SX,G,N17][+$i++];   # loop through digit names
    print str_repeat($i,$a[$i+48])              # print digit repeatedly
)
    for($p=0;$c=ord($s[$p]);)                   # loop through name
        $a[$i+48]+=                                 # add to digit count
        ($p++?-1:1)*                                # (add first, subtract other)
        $a[$c];                                     # character occurences

ONEएक के साथ एकमात्र शब्द नहीं है O, इसलिए इसे W(केवल दिखाई देने वाले TWO) और U(केवल दिखाई देने वाले FOUR) और इसी तरह की गणना को घटाना होगा ।
NINEविशेष है, क्योंकि यदि मैं अक्षरों का उपयोग करता हूं (तो इसकी आवश्यकता होगी I-X-G-F+Uया नहीं) घटाना नहीं हैN-O-S+W+U+X ), तो , इसलिए मैं इसके बजाय अंक गणना का उपयोग करता हूं।

PHP, 160 बाइट्स

$a=count_chars($argn);foreach([W2O,U4FOR,X6SI,G8I,F5I,O1,R3,S7,I9]as$s)for(${$s[$p=1]}+=$n=$a[ord($s)];$c=ord($s[++$p]);)$a[$c]-=$n;while($$i--?print$i:$i++<9);

सभी ऊपरी मामले इनपुट मानता है; चरित्रों को तराशा जा सकता है। ऑनलाइन के
साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

व्याख्या

अंकों के माध्यम से छोरों, इनपुट में अपने अद्वितीय वर्णों की घटनाओं की गिनती और अन्य वर्णों की गिनती को कम करने की प्रक्रिया में। "अन्य वर्ण" कर सकते हैं शब्द के अन्य सभी वर्णों का अर्थ है; लेकिन केवल उन पर विचार करना जिनकी बाद में 19 बाइट्स बचाए जाने की आवश्यकता होगी।

रूपांतरण हो रहा है str_repeatलूप को एक संयुक्त लूप में 5 बाइट्स को सहेजता है।

और डिजिट काउंट के लिए वैरिएबल वैरिएबल का उपयोग करके एक और 8 को बचाया गया।

टूट - फूट

$a=count_chars($argn);                              # count character occurences in input
foreach([W2O,U4FOR,X6SI,G8I,F5I,O1,R3,S7,I9]as$s)   # loop through digit names
    for(${$s[$p=1]}+=                                   # 2. add to digits count
        $n=$a[ord($s)];                                 # 1. get count of unique character
        $c=ord($s[++$p]);)                              # 3. loop through other characters
        $a[$c]-=$n;                                         # reduce character count
while(
    $$i--?print$i                                       # print digit repeatedly
    :$i++<9);                                       # loop through digits