क्रमबद्ध-आउट क्रम संख्याएँ

Question

दो या दो से अधिक समान लंबाई के क्रमबद्ध-आउट सीरियल नंबर की सूची को देखते हुए, जैसे

[[ "three" , "one"  , "four"  ],
 [ "one"   , "five" , "nine"  ],
 [ "two"   , "six"  , "five"  ],
 [ "three" , "five" , "eight" ]]

शब्दों को दर्शाने वाली संख्याओं के आधार पर सूची को क्रमबद्ध करें:

[[ "one"   , "five" , "nine"  ],
 [ "two"   , "six"  , "five"  ],
 [ "three" , "one"  , "four"  ],
 [ "three" , "five" , "eight" ]]

आपको कम या ऊपरी में वर्तनी की संख्या की आवश्यकता हो सकती है, लेकिन मिश्रित नहीं, मामला।

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

[["three","one","four"],["one","five","nine"],["two","six","five"],["three","five","eight"]]
देता है
[["one","five","nine"],["two","six","five"],["three","one","four"],["three","five","eight"]]

[["two","seven"],["one","eight"],["two","eight"],["one","eight"],["two","eight"],["four","five"]]
देता है
[["one","eight"],["one","eight"],["two","seven"],["two","eight"],["two","eight"],["four","five"]]

[["one","four","one","four","two"],["one","three","five","six","two"],["three","seven","three","zero","nine"]]
देता है
[["one","three","five","six","two"],["one","four","one","four","two"],["three","seven","three","zero","nine"]]

[["zero","six","one"],["eight","zero","three"],["three","nine","eight"],["eight","seven","four"],["nine","eight","nine"],["four","eight","four"]]
देता है
[["zero","six","one"],["three","nine","eight"],["four","eight","four"],["eight","zero","three"],["eight","seven","four"],["nine","eight","nine"]]

Comments

यकीन नहीं होता अगर मुझे यह सही ढंग से मिला, क्या ["three","one","four"] === 314?

— लीख

@ ठीक है, यह सही है।

— 20

@ नंबर वे वर्तनी से बाहर। जैसे [314,159,265,358]→ [159,265,314,358]।

— 20

क्या हम संख्याओं का एक निश्चित मनमाना पूंजीकरण मान सकते हैं?

— dylnan

@dylnanYou may require the numbers to be spelled in lower or upper, but not mixed, case.

— अमानवीय

Answer 1

भूसी , ९ by बाइट्स

Ö†€¨tfṡn

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

पुनरावर्ती के स्टैक्स उत्तर द्वारा एल्गोरिथम "प्रेरित" (मैंने सिर्फ लुकिंग स्ट्रिंग को थोड़ा बदल दिया है), उसे ऊपर ले जाएं!

चाल स्ट्रिंग में अपनी स्थिति के लिए प्रत्येक अक्षर को मैप कर रही है tfsen(इस कार्यक्रम के अंत में संकुचित)। भूसी सूची 1-आधारित हैं, और लापता आइटम 0 लौटते हैं, इसलिए हमें यह मैपिंग मिलती है:

"one"        [0,5,4]
"two"        [1,0,0]
"three"      [1,0,0,4,4]
"four"       [2,0,0,0]
"five"       [2,0,0,4]
"six"        [3,0,0]
"seven"      [3,4,0,4,5]
"eight"      [4,0,0,0,1]
"nine"       [5,0,5,4]

जैसा कि आप देख सकते हैं, सूचियां पूरी तरह से आदेशित हैं।

---

स्पष्ट होने के लिए, यहां हस्क (और कई अन्य भाषाओं में) की तुलना में सूची कैसे काम करती है:

1. यदि दो सूचियों में से एक खाली है, तो वह छोटी है।
2. यदि दो सूचियों के पहले तत्व अलग हैं, तो पहले छोटे तत्व के साथ एक छोटी सूची है।
3. अन्यथा, दोनों सूचियों से पहला तत्व छोड़ें और वापस बिंदु 1 पर जाएं।

Comments

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

— पुनरावर्ती

... अगर यह सिर्फ अक्षर थे तो यह हो सकता है tfrsenलेकिन मैं अनुमान लगा रहा हूं कि जैसे शब्द हैं withऔर senइसमें संपीड़न में मदद मिलती है।

— जोनाथन एलन

धन्यवाद दोस्तों, आपने मुझे एक और भी छोटे स्ट्रिंग को खोजने के लिए प्रेरित किया: D

— Leo

तो, यह पहले अल्पविराम के बाद एक दशमलव बिंदु के साथ अल्पविराम की जगह लेने जैसा है?

— स्ट्रॉबेरी

@ स्ट्रॉबेरी वास्तव में नहीं, [1,0,0]की तुलना में छोटी मानी जाती है [1,0,0,0](लेकिन इस कार्यक्रम के लिए इससे कोई फर्क नहीं पड़ेगा)

— सिंह

Answer 2

स्टैक्स , 24 22 17 16 14 बाइट्स

▄Ωφ▐╧Kìg▄↕ñ▼!█

इसे चलाएं और डीबग करें

यह कार्यक्रम इनपुट के लिए निचली वर्तनी वर्तनी के सरणियों को लेता है। आउटपुट न्यूलाइन-अलग है जैसे।

one five nine
two six five
three one four
three five eight

यह कार्यक्रम एक विशिष्ट परिवर्तन के तहत प्राप्त आदेश का उपयोग करके इनपुट को सॉर्ट करता है। प्रत्येक शब्द के प्रत्येक अक्षर को स्ट्रिंग में इसके सूचकांक द्वारा प्रतिस्थापित किया जाता है "wo thif sen"। इस आदेश द्वारा मूल सरणियों को क्रमबद्ध किया जाता है। फिर रिजल्ट के साथ जुड़ने के बाद रिजल्ट प्रिंट होते हैं।

रिक्त स्थान बिना किसी उद्देश्य के काम करते हैं, लेकिन वास्तव में स्ट्रिंग शाब्दिक में अधिक से अधिक संपीड़न की अनुमति देते हैं।

Comments

Stax क्या उपयोग करता है? UTF-8 में यह 32 बाइट्स है।

— OldBunny2800 22

"बाइट्स" हाइपरलिंक की तरह संशोधित CP437।

— पुनरावर्ती

क्या इस तरह की स्ट्रिंग के साथ आने के लिए कुछ मानक एल्गोरिदम / विधि है? क्या अवधारणा का कोई नाम है?

— इताई

@ इताई: ऐसा लगता है कि यह होगा, लेकिन मुझे नहीं पता कि यह क्या है।

— पुनरावर्ती

Answer 3

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

OḌ%⁽Т%147µÞ

एक मोनडिक लिंक।

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

कैसे?

अंकों को अध्यादेशों में बदलना और फिर बेस 10 से फिर 4752 तक मोडुलोस लेना 147 फिर एक असेंबलिंग देता है:

 zero            , one         , two         , three               , four
[122,101,114,111],[111,110,101],[116,119,111],[116,104,114,101,101],[102,111,117,114]
 133351          , 12301       , 12901       , 1276511             , 114384
 295             , 2797        , 3397        , 2975                , 336
 1               , 4           , 16          , 35                  , 42

 five            , six         , seven               , eight               , nine
[102,105,118,101],[115,105,120],[115,101,118,101,110],[101,105,103,104,116],[110,105,110,101]
 113781          , 12670       , 1263920             , 1126456             , 121701
 4485            , 3166        , 4640                , 232                 , 2901
 75              , 79          , 83                  , 85                  , 108

इसके बाद इसे एक महत्वपूर्ण फ़ंक्शन के रूप में उपयोग किया जा सकता है, जिसे क्रमबद्ध करना है:

OḌ%⁽Т%147µÞ - Link: list of lists of lists of characters
          µÞ - sort (Þ) by the mondadic chain to the left (µ):
O            -   ordinals of the characters
 Ḍ           -   convert from base 10
   ⁽Т       -   literal 4752
  %          -   modulo
      %147   -   modulo by 147

Comments

यह कुछ अद्भुत तौर-तरीके हैं जो आपने अभी तक पाए हैं, मुझे लगता है कि यह श्रमसाध्य था।

— निकोल आउटफोलर

यह सब श्रमसाध्य नहीं है - मैंने पहले बाइनरी को देखा था।

— जोनाथन एलन

जैसे, आपने मॉडुलोस को क्रूरता से मजबूर किया, नहीं?

— E बजे

हाँ, लेकिन यह जल्दी था।

— जोनाथन एलन

Answer 4

पायथन , 62 बाइट्स

lambda m:sorted(m,key=lambda r:[int(s,36)%6779%531for s in r])

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

ध्यान दें:

lambda m:sorted(m,key=lambda r:[map("trfsen".find,s)for s in r])

जो पायथन 2 में काम करता है (लेकिन 3 नहीं) दो बाइट्स से लंबा है।

Comments

आपने मैजिक नंबर कैसे खोजे?

— mbomb007 19

परिणामों पर सख्ती से बढ़ने के लिए बस नेस्टेड लूप की जाँच। हालाँकि मैंने संभवतः बाहरी दिए गए आंतरिक की अंक लंबाई को रोक दिया था।

— जोनाथन एलन

Answer 5

APL (Dyalog Classic) , 12 बाइट्स

'nesft'∘⍒⌷¨⊂

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

यह है कि मुझे डायडिक के लिए एक उपयुक्त बाएं तर्क मिला ⍒(मैंने कोशिश की ⍋और लंबाई पहले 6):

A←⊖a←↑'zero' 'one' 'two' 'three' 'four' 'five' 'six' 'seven' 'eight' 'nine'
{(a≡a[⍵⍒a;])∧A≡a[⍵⍒A;]:⎕←⍵}¨,⊃∘.,/5⍴⊂∪∊a

Answer 6

पर्ल 6 , 37 बाइट्स

*.sort:{('digit 'X~$_)».parse-names}

कोशिश करो

विस्तारित:

*\     # WhateverCode lambda (this is the parameter)
.sort:
{  # block with implicit parameter ｢$_｣
  (
    'digit ' X~ $_  # concatenate 'digit ' to each named digit
  )».parse-names    # call .parse-names on each
}

कोड ब्लॉक फॉर्म का एक मूल्य लेगा ("three","one","four")और उसका अनुवाद करेगा ("3","1","4")जो एक ऐसा मूल्य है जो .sortआसानी से उपयोग कर सकता है।

Answer 7

APL (Dyalog) , 38 बाइट्स

{⍵[⍋(531∘⊥⍤1)(531|6779|36⊥9+⎕A⍳⊢)¨↑⍵]}

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

जोनाथन एलन के भयानक समाधान के आधार पर ।

Comments

@JonathanAllan मैंने प्रारंभिक चेंजिग के दौरान एक क्रेडिट संपादित किया .. मुझे पता नहीं है कि यह अपरिवर्तित क्यों था। अब ठीक किया गया है

— Uriel

31:, ⊂⌷¨⍨∘⍋(531⊥531|6779|36⊥9+⎕A⍳⊢)¨लेकिन आप अपने वर्तमान बाइट की गिनती के आधे से भी कम समय में यह बहुत सरल कर सकते हैं।

— आदम

@ तो, आप अलग-अलग स्वरूपों में इनपुट और आउटपुट को मिलाते हैं (मिश्रित बनाम असम्बद्ध)?

— ngn

@ngn ज़रूर। लेकिन मेरे पास जो समाधान है वह पूरी तरह से I / O को मिलाया गया है।

— आदम

Answer 8

रूबी, 48 बाइट्स

->x{x.sort_by{|y|y.map{|s|s.to_i(35)**2%47394}}}

इस तथ्य का दुरुपयोग करते हैं कि "zero".to_i(35)0 है (चूंकि 'z' आधार 35 में एक वैध अंक नहीं है), इसलिए यह अन्य नौ अंकों के लिए एक सूत्र को बाध्य करना बहुत आसान है।

Answer 9

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

{x@<"tfsen"?x}

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

Answer 10

जावास्क्रिप्ट (Node.js) , 70 बाइट्स

a=>a.sort((a,b)=>(g=a=>a.map(c=>99+parseInt(2+c,34)%607%292))(a)>g(b))

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

Answer 11

रूबी , 47 बाइट्स

->x{x.sort_by{|y|y.map{|s|s.to_i(32)%774%538}}}

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

इस तथ्य का उपयोग करता है कि अधिकतम अंकों से कम आधार का उपयोग करने से शून्य का परिणाम होता है (जैसा कि उनके उत्तर में हिस्टोक्रेट द्वारा इंगित किया गया है )

Answer 12

अजगर 2 , 85 81 80 बाइट्स

बस संख्या निर्धारित करने के लिए प्रत्येक शब्द के पहले दो अक्षरों का उपयोग करता है, फिर कुंजी के रूप में उस अनुक्रमण फ़ंक्शन का उपयोग करके प्रत्येक सूची को सॉर्ट करें।

lambda _:sorted(_,key=lambda L:['zeontwthfofisiseeini'.find(s[:2])/2for s in L])

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

जोनाथन एलन के लिए धन्यवाद, 4 बाइट्स बचाए

Comments

मुख्य कार्य में लूप सूची की समझ के लिए 4 बाइट्स छोटी होती हैं।

— जोनाथन एलन

Answer 13

रूबी , 49 बाइट्स

->x{x.sort_by{|y|y.map{|s|s.to_i(36)**4%463595}}}

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

Answer 14

05AB1E , 27 बाइट्स

Σ“¡×€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“#skJ

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

---

Σ                           # Sort input by...
 “¡×€µ‚•„í†ìˆÈŒšï¿Ÿ¯¥Š“     # "zero one two three four five size seven eight nine"
                       #    # Split on spaces.
                        sk  # Find index of each input...
                          J # Join up.

Comments

25 बाइट्स

— काल्डो

@ कल्दो आह ... प्रत्येक के शुरुआती 2 अक्षर एन्कोडिंग? मुझे ऐसा लगता है कि इसका खुद का जवाब होना चाहिए।

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

Answer 15

हास्केल , 133 122 109 107 106 बाइट्स

import Data.List
sortOn$abs.read.(>>=show.head.(`elemIndices`words"ze on tw th fo fi si se ei ni").take 2)

Ungolfed:

import Data.List

nums = ["ze","on","tw","th","fo","fi","si","se","ei","ni"]

lookup' :: Eq a => a -> [a] -> Int
lookup' v = head . elemIndices v

wordToInt :: String -> Int
wordToInt (x:y:_) = lookup' [x,y] nums

wordsToInt :: [String] -> Int
wordsToInt = read . concatMap (show . wordToInt)

sortN :: [[String]] -> [[String]]
sortN = sortOn wordsToInt

Answer 16

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

lambda m:sorted(m,key=lambda r:[hash(s)%2249518for s in r])

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

जोनाथन एलन के अजगर 3 समाधान पर रीफिंग ...

Answer 17

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

l->{l.sort((a,b)->s(a)-s(b));}
int s(String[]a){int v=0;for(var s:a)v=v*99+"zeontwthfofisiseini".indexOf(s.substring(0,2));return v;}

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

Answer 18

रूबी , 64 बाइट्स

->a{a.sort_by{|b|b.map{|n|"zeontwthfofisiseeini".index n[0,2]}}}

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

एक लैम्ब्डा स्ट्रिंग्स के 2 डी ऐरे को स्वीकार करता है और स्ट्रिंग्स का 2 डी ऐरे लौटाता है।

Mbomb007 के पायथन 2 के पिग्गीबैकिंग -26 बाइट्स के लिए मैं क्या पोस्ट करने वाला था, के बारे में बाइट्स का जवाब देता हूं।

Answer 19

पर्ल 5 , 103 बाइट्स

sub c{pop=~s%(..)\w+\s*%zeontwthfofisiseeini=~/$1/;$`=~y///c/2%ger}say s/\R//gr for sort{c($a)<=>c$b}<>

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

Answer 20

रेटिना 0.8.2 , 38 बाइट्स

T`z\o\wit\hfsen`d
O`
T`d`z\o\wit\hfsen

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण सूट शामिल है। zowithfsenउस स्ट्रिंग में अपनी स्थिति के साथ अक्षरों को अस्थायी रूप से प्रतिस्थापित करके काम करता है , जो संख्याओं को शाब्दिक रूप से क्रमबद्ध करने की अनुमति देता है।

Answer 21

जेली , 30 28 27 बाइट्स

w@€“¡¦ẇṆb~ṇjṚØ%ĖġṘḥḞṾṇJḌ»µÞ

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

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

स्ट्रिंग 'onetwo ... नौ' में प्रत्येक अंक के सूचकांक को ढूँढता है और फिर एक महत्वपूर्ण फ़ंक्शन के रूप में इसका उपयोग करता है Þ। 'zero'शुरुआत में शामिल करने की आवश्यकता नहीं है क्योंकि पहले दो वर्णों की खोज 'zero'विफल 0हो जाएगी और इसे इंडेक्स के बजाय लौटा दिया जाएगा, जिससे 'zero'लेक्सोग्राफिक रूप से "जल्दी" बन जाएगा।

Comments

'एक दो ... नौ' के संपीड़न का उपयोग करना एक बाइट कम है

— जोनाथन एलन

@JonathanAllan आह, धन्यवाद। मैंने ऐसा नहीं सोचा था। 'zeontw...ni'लंबे समय तक संपीड़ित रहना समाप्त हुआ।

— डायलन

... अब नहीं ... "पहले दो अक्षर"।

— जोनाथन एलन

Answer 22

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

print(sorted(eval(input()),key=lambda l:int(''.join([str("zero one two three four five six seven eight nine".split().index(i))for i in l]))))

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

Comments

131 बाइट्स

— caird coinheringaahing

Answer 23

सी (क्लैंग) , 229 बाइट्स

y,j,k,t[9];char *s="zeontwthfofisiseeini";r(char **x){for(j=y=k=0;k+1<strlen(*x);k+=j,y=y*10+(strstr(s,t)-s)/2)sscanf(*x+k,"%2[^,]%*[^,]%*[,]%n",t,&j);return y;}c(*x,*y){return r(x)-r(y);}f(*x[],l){qsort(&x[0],l,sizeof(x[0]),c);}

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

सी फ़ंक्शंस के लिए सरणी के सरणी भेजने का कोई सीधा तरीका नहीं है, इसलिए कोड-गोल्फ की भावना में, मैंने इनपुट प्रारूप में एक मामूली स्वतंत्रता ली है।

f()स्ट्रिंग के लिए पॉइंटर्स की एक सरणी को स्वीकार करता है, जहां प्रत्येक स्ट्रिंग एक संख्या है, जो लोअर-केस में अल्पविराम से अलग वर्तनी-अंको द्वारा दर्शाया गया है। इसके अतिरिक्त, इसे दूसरे पैरामीटर में सरणी में स्ट्रिंग्स की संख्या की आवश्यकता होती है। मुझे उम्मीद है कि यह स्वीकार्य है।

f()उपयोग किए गए क्रम में जगह में संकेत की जगह qsort()।
r()कॉमा से अलग संख्या स्ट्रिंग से इनपुट नंबर पढ़ता है। यह केवल संख्या की पहचान करने के लिए पहले दो वर्णों की तुलना करता है।
c()तुलना समारोह है

Comments

207 बाइट्स

— सीलिंगकैट

@ceilingcat क्या आप कृपया समझा सकते हैं strstr("i"-19,t)-"zeontwthfofisiseeini"? यह संकलक-विशिष्ट या मानक है?

— जीपीएस

इस पर निर्भर करता है कि वहाँ कोई अन्य पैटर्न नहीं .rodataदिख रहा है जैसे 0x69 0x00और संकलक का पता रखने "i"के अंत में"zeo..."

— छत पर

ऐसा सोचा .. क्या कंपाइलर सुनिश्चित करने का एक तरीका है? मुझे पता है कि यहाँ नियम इसकी अनुमति देते हैं, लेकिन क्या मैं इस पर वास्तविक रूप से निर्भर हो सकता हूं?

— जीपीएस

मेरी वृत्ति "वास्तविक दुनिया" में इससे बचने के लिए है, लेकिन यह संभवतः अच्छी तरह से काम करेगा यदि आपके स्ट्रिंग टुकड़े पर्याप्त रूप से अद्वितीय हैं। वास्तव में स्टैक कैनरी से संबंधित कुछ वैध उपयोग का मामला हो सकता है, लेकिन मैं भी केवल मतिभ्रम हो सकता है।

— छत