एक संख्या को आकार दें
पहचान
एक पूरी संख्या \$< 100,\$ संख्या के अंग्रेजी प्रतिनिधित्व को बढ़ाएँ / छोटा करें क्योंकि इसके मान जितने वर्ण हैं।
सैंडबॉक्स
नियमों
नंबर ले लो \$n\$, और इसे इस शब्द से शब्दों में मिलता है । आप इस शब्दकोश को किसी भी तरह से पसंद कर सकते हैं। (एक सूची, लिंक से पढ़िए, कमांड लाइन आर्ग, एसटीडीआईएन, वैरिएबल, इत्यादि।)
यहाँ JSON Array के रूप में फ़ाइल है। (लायक्स के सौजन्य से)
फिर, स्ट्रिंग के साथ निम्नलिखित करें:
- यदि स्ट्रिंग की लंबाई संख्या से कम है, तो उसके कुछ पात्रों को तब तक दोहराएं, जब तक लंबाई संख्या से मेल नहीं खाती।
- पहले और अंतिम वर्णों को दोहराया नहीं जाना चाहिए, और अन्य वर्णों की पुनरावृत्ति की संख्या सबसे अधिक भिन्न होनी चाहिए (इसलिए आप उनमें से कुछ को 5 बार और अन्य को 6 बार दोहरा सकते हैं, उदाहरण के लिए; यह कोई फर्क नहीं पड़ता कि कौन से हैं; बिल्कुल सही)।
- यदि स्ट्रिंग की लंबाई संख्या से अधिक है, तो लंबाई को मैच करने के लिए पहले और अंतिम को छोड़कर इसके किसी भी वर्ण को हटा दें। 1 और 0 अपवाद हैं, क्योंकि वे बहुत छोटे हैं।
- स्ट्रिंग में अक्षरों का क्रम बनाए रखा जाना चाहिए।
- उदाहरण:
50 → f[ift]y → 3 letters must be duplicated 16 times
61 → s[ixtyon]e → 5 letters must be duplicated 10 times, 1 character must be duplicated 9 times
कदम-दर-कदम
एक उदाहरण के रूप में 11 लेना,
(के रूप में स्वरूपित word → length)
eleven → 6
^
elleven → 7
^
elleeven → 8
^
elleevven → 9
^
elleevveen → 10
^
ellleevveen → 11 (end)
उदाहरण
2 → to
3 → the or tre or tee
4 → four
5 → fiive or fivve
7 → seevven or sevveen or seeveen
10 → teeeeeeeen
Special cases:
0 → (Any null value/no output)
1 → o
जीत का मानदंड
यह कोड-गोल्फ है । प्रत्येक भाषा में सबसे छोटा कोड जीतता है।
एलटीएम बाउंटी !
इस सवाल का पहला हस्क जवाब मुझे जरगब के इनाम के शीर्ष पर से +50 प्रतिनिधि इनाम मिलेगा, अगर यह अतिरिक्त प्रयास भाग में यहां दिए गए मानदंडों को संतुष्ट करता है ।
जवाब
आर , (110 105 96) 96 95 बाइट्स
उम्मीद है कि अब सही प्रश्न का उत्तर दे रहा है ...
function(n,a)cat(substring(b<-a[n+1],r<-sort(c(1,l<-nchar(b),rep(3:l-1,n))[1:n]*!!n),r),sep='')
इसे ऑनलाइन आज़माएं!
दोहे! प्रश्न पढ़ें, बेवकूफ!
ठीक है, पहले (कई) प्रयास सही सवाल का जवाब नहीं दे रहे थे, क्योंकि मैंने चुनौती को ठीक से नहीं पढ़ा था और ध्यान नहीं दिया था कि पहले + अंतिम पात्रों को दोहराया नहीं जाना चाहिए। संयोग से, हालांकि, निकट-पूर्ण-पुनः एक ही नंबर के बाइट्स में बाहर आ गया!
कैसे? अघोषित कोड:
size_up=
function(n,a){ # n is number, a is array of text strings
b=a[n+1] # get the text string for this number
l=nchar(b) # get the number of characters
r=sort( # r = sort the indices of characters to output:
c(1,l, # we need index 1 and the last index (l)...
rep(2:(l-1),n)) # then plenty of repeats of 2..(l-1) ...
[1:n]) # and, from this, we'll use the first n.
if(n) # only output anything if n>0 ...
cat(substring(b,r,r),sep='')
# ...in which case concatenate the indexed
} # characters of the text string b.
हास्केल , 59 बाइट्स
d!n|h:t<-d!!n=take n$h:[t!!div(i*length t-i)(n-1)|i<-[1..]]
इसे ऑनलाइन आज़माएं!
उपयोग: ["zero","one",...]!n।
उदाहरण के लिए, इनपुट के लिए 11, इसके 'e'बाद "leven"अनुक्रमणित किया जाएगा : $$ \ left \ lfloor \ frac {4} {10} \ right \ rfloor, \ left \ lfloor \ frac {8} [10} \ right \ rfloor , \ dots, \ बाएँ \ lfloor \ frac {40} {10} \ right \ rfloor $ $ जो है "lleevvveen"। (सहज रूप से, सूत्र [०.१.१] के सूचकांक [०.४] तक फैला है "leven"।)
take n$का उपयोग 0 मामले (अन्यथा आउटपुट है "z") का समर्थन करने के लिए किया जाता है , लेकिन यह हमें [1..]इसके बजाय लिखने देता है [1..n-1], इसलिए शुद्ध लागत 7 के बजाय केवल 4 बाइट्स है।
हस्क , 28 27 25 22 21 बाइट्स
संपादित करें: ज़र्ब के लिए -2 बाइट्स, जो किंग के लिए -3 और बाइट्स के लिए धन्यवाद, और फिर ज़र्ब के लिए फिर से -1 बाइट्स धन्यवाद (उन आखिरी 4 बाइट्स ने काम के माध्यम से कुछ समय लिया और समझते हैं; मैंने एक स्पष्टीकरण जोड़ा है लेकिन यह मेरे जैसे भूसी के लिए आसान नहीं है ...)
SṀ!(O↑¹:1S:ȯ*¹…2←L)!→
इसे ऑनलाइन आज़माएं!
मेरा पहला हस्क जवाब, 'महीने की भाषा' से प्रेरित है। मेरे आर उत्तर
में दृष्टिकोण का पोर्ट । मुझे यह जानकर बहुत खुशी हुई कि वर्किंग प्रोग्राम (हुर्रे!) लिखने का तरीका क्या है, इसलिए यह लगभग निश्चित रूप से उतना गॉल्फ़ नहीं है जितना यह हो सकता है ...
कैसे? (ज़गरब और जो किंग के गोल्फ के बाद टिप्पणी की गई: अब यह काफी जटिल है ...):
सबसे पहले, हम सभी निहित तर्क (सुपरस्क्रिप्ट के रूप में ⁰और ²) डालेंगे :
SṀ!(O↑²:1S:ȯ*²…2←L)!→²⁰
अब टिप्पणी कोड:
S # S is a 'hook' combinator to recycle argument x: Sfgx == fx(gx)
Ṁ! # f is M! = map the list-index function across a list of indexes, with the list to index given by argument x
(O↑²:1S:ȯ*²…2←L) # g is (O↑²:1S:ȯ*²…2←L) = function to generate the list of indexes from argument x (see below)
!→²⁰ # x is !→²⁰ = the text name of the number (for instance, "twenty"; see below)
# Explanation of g:
S # S 'hook' combinator again, so Sfgy here == fy(gy)
: # f is : = prefix with y
ȯ # g is given by ȯ*²…2←
# ȯ is 3-function combinator: ȯfgh == single function fgh
← # subtract 1
…2 # and construct a series from 2..this value,
*² # and repeat this series n times, with n given by argument 2 (first given program argument);
# so ȯ*²…2← is the function that repeats 2..x, n times, for argument y
L # y is the length of the argument x
# So: up to here, we have :Lx *²…2←Lx
:1 # Now prefix with 1...
↑² # then select the first n elements, with n given by argument 2 (first given program argument)...
O # and sort the result. This is the list of indexes from x.
# Explanation of x:
! ⁰ # element of argument 1 (second given), indexed by...
→² # argument 2 (first given) +1
जेली , 20 बाइट्स
ị©L⁸,_2œs/Ẉ⁸>Ø.¤j®x"
एक डाइएडिक लिंक जो बाईं ओर की संख्या और दाईं ओर संख्या के नामों की सूची को स्वीकार करता है (जेली इंडेक्स ऑर्डर में), जो वर्णों की एक सूची देता है।
इसे ऑनलाइन आज़माएं! या सभी 100 देखें।
कैसे?
ị©L⁸,_2œs/Ẉ⁸>Ø.¤j®x" - Link: N, Words
ị - (N) index into (Words) -> the word
© - copy for later
L - length
⁸ - chain's left argument -> N
, - pair -> [N, length(Word)]
_2 - subtract two -> [N-2, length(Word)-2]
/ - reduce using:
œs - split (implicit range [1..N-2]) into (length(Word)-2)
approximately equal parts
Ẉ - length of each -> sizes (call this [s1, s2, ...])
¤ - nilad followed by link(s) as a nilad:
⁸ - chain's left argument -> N
Ø. - bits -> [0,1]
> - greater than? -> [N>0, N>1]
j - join -> [N>0, s1, s2, ..., N>1]
® - recall from earlier -> the word
" - zip with:
x - repeat
जे , 40 39 बाइट्स
[{.[(]#~1:0 _1}2+/@}.($[:}:@}.@=#\))>@{
इसे ऑनलाइन आज़माएं!
पायथन 3 , 98 बाइट्स
def f(n,a):x,*s,y=a[n];l=len(s);d=n-2;a[0]=(x+"".join(s[i]*(d//l+(i<d%l))for i in range(l))+y)[:n]
इसे ऑनलाइन आज़माएं!
-8 बाइट्स ओक्स
-2 बाइट्स के लिए धन्यवाद pxeger के लिए धन्यवाद
(-9 बाइट्स दोनों के बीच क्योंकि बचा बाइट्स में से एक दो अनुकूलन के बीच ओवरलैप हो जाता है)
-9 और बाइट्स ओव्स के लिए धन्यवाद
जावास्क्रिप्ट (ईएस 6), 78 73 बाइट्स
की उम्मीद है (n)(dictionary)। शून्य के लिए एक रिक्त स्ट्रिंग देता है।
n=>d=>(s=d[n--],g=k=>k<n?s[~k?k/~-n*(s.length-2)+1|0||2:0]+g(k+1):'')(-1)
इसे ऑनलाइन आज़माएं!
के (ओके) , 50 46 40 बाइट्स
-4 बाइट्स ओव्स के लिए धन्यवाद
-6 बाइट्स कोल्टिम के लिए धन्यवाद
{x#,/(1,(+/'(-2+#y@x;0N)#2_x#1),1)#'y@x}
इसे ऑनलाइन आज़माएं!
जंग, 203 बाइट्स
|i,a|if i<2{a[i].truncate(i)}else
if let[f,m@..,l]=&*a[i].clone(){let mut v:Vec<_>=(0..m.len()).cycle().take(i-2).collect();v.sort();a[i]=v.iter().map(|&j|m[j]).collect();a[i].insert(0,*f);a[i].push(*l)}
इसे ऑनलाइन आज़माएं
प्रकार का एक बंद fn(usize,&mut [Vec<char>])। परिणाम में लिखा है a[i]।
एपीएल (डायलॉग यूनिकोड) , 39 37 36 बाइट्स
-2 बाइट्स रजीटाइम के लिए धन्यवाद ! जो राजा
को -1 धन्यवाद !
मान लेता है ⎕IO←0।
⊃∘⌷{⍵↑⍺/⍨1,⍨1,(⍵-2)(⌊÷+|⍨>∘⍳⊢)≢2↓⍺}⊣
इसे ऑनलाइन आज़माएं!
व्याख्या
यह फ़ंक्शन शब्दकोश को सही तर्क के रूप में लेता है और पूर्णांक को बाएं तर्क के रूप में।
⊃∘⌷एक ऐसा फंक्शन है जो शब्द को दाईं डिक्शनरी में लेफ्ट इंडेक्स में मिलता है।
⊣बाईं पहचान फ़ंक्शन है।
आंतरिक फ़ंक्शन { ... }को तब शब्द के साथ बाएं तर्क ⍺और पूर्णांक को एक सही तर्क के रूप में कहा जाता है ⍵।
≢2↓⍺पहले दो वर्णों के बिना शब्द की लंबाई है ( a)।
⍵-2बस पूर्णांक इनपुट माइनस 2( b) है।
इन दो तर्कों के साथ फ़ंक्शन ⌊÷+|⍨>∘⍳⊢को कहा जाता है:
⍳⊢एक इंडेक्स वेक्टर बनाता है 0 1 ... a-1।
|⍨गणना करता है b mod a।
>सूचकांक वेक्टर है, जो एक बूलियन वेक्टर साथ में जो परिणाम को यह तुलना b mod a 1की और a - b mod a 0के।
⌊÷की मंजिल है b÷a।
+यह बूलियन वेक्टर में जोड़ता है।
1,पहले जोड़ता है एक 1, 1,⍨एक संलग्न कर देता है 1।
⍺/vजैसा कि संकेत दिया गया है, शब्द x से कई आइटम का चयन करता है v। उदाहरण: 1 3 2 2 2 1/'eleven'≡'ellleevveen'। ⍨कोष्ठक से बचने के लिए यह यहाँ ( ) प्रतिबद्ध है।
⍵↑फिर आवश्यक संख्या में वर्ण लेता है। इस के लिए आवश्यक है 0और 1।
चारकोल , 29 बाइट्स
ＮθＦ⊕θＳηＦθ§η∧ι⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹
इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। नंबर और फिर शब्दकोश के रूप में इनपुट लेता है। Ｆ⊕θＳηपहली पंक्ति पर दी गई लंबाई के लिए दूसरी पंक्ति का आकार बदलने वाले प्रोग्राम में परिणाम निकालना । Annoyingly, 2, इस प्रक्रिया को करने के लिए सबसे मुश्किल संख्या के बाद से दोनों पहली और आखिरी चरित्र बढ़त मामले हैं। स्पष्टीकरण:
Ｎθ
इनपुट n।
Ｆ⊕θＳη
तब तक शब्दकोश में पढ़ें और जब तक प्रवेश के लिए शामिल न हो जाएं n।
Ｆθ
nपात्रों पर पाश । ( ⭆θभी काम करता है।)
§η
गणना किए गए सूचकांक द्वारा दिए गए शब्द शब्द के चरित्र का आउटपुट।
∧ι
आउटपुट के पहले चरित्र के लिए कंप्यूटेड इंडेक्स हमेशा होता है 0।
⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹
अन्यथा से स्ट्रिंग के अंत के लिए दूरी पैमाने पर 0..n-2करने के लिए 0..l-2(जहां lशब्दकोश शब्द की लंबाई है), को गिरफ्तार। ध्यान दें कि यह परिणाम के 0/0लिए है n=2, इसलिए भाजक 1इस मामले में मजबूर है । इसके लिए उदाहरण n=5, five:
i=0 o=0
i=1 o=3-ceil((4-1)*(4-2)/(5-2))=3-ceil(3*2/3)=3-2=1
i=2 o=3-ceil((4-2)*(4-2)/(5-2))=3-ceil(2*2/3)=3-2=1
i=3 o=3-ceil((4-3)*(4-2)/(5-2))=3-ceil(1*2/3)=3-1=2
i=4 o=3-ceil((4-4)*(4-2)/(5-2))=3-ceil(0*2/3)=3-0=3
इसलिए उत्पादन सूचकांक में 0, 1, 1, 2, 3परिणाम हैं fiive। (वास्तव में गणना नकारात्मक सूचकांकों का उपयोग करके की जाती है, इसलिए वास्तविक सूचकांक हैं 0, -3, -3, -2, -1, जिसका अर्थ है कि वे वास्तव में नीचे गोल हैं, बल्कि फिर ऊपर हैं।)
पर्ल 5 , 77 बाइट्स
sub{@w=@{$d[$n=pop]};$h=$n<4?2:(@w-2)/($n-2);join'',@w[map.99+$h*$_,0..$n-1]}
इसे ऑनलाइन आज़माएं!
स्काला, 93 बाइट्स
i=>a=>{val f+:m:+l=a(i);(f+:Seq.fill(i)(m.indices).flatten.take(i-2).sorted.map(m):+l)take i}
इसे ऑनलाइन आज़माएं!
प्रकार के एक कार्य को परिभाषित करता है Int=>Seq[Seq[Char]]=>Seq[Char]।
स्पष्टीकरण:
i => a => { // define a curried lambda function with two arguments
val f+:m:+l = a(i) // destructure the string to extract the first and last letter
( // return...
f +: // the first letter prepended to
Seq.fill(i)(m.indices) // the numbers from 0 to i-2, all repeated i times
// for "seven", this is 7 instances of [0,1,2]
.flatten // flatten this list
.take(i-2) // take the first i-2 numbers from the list
.sorted // sort them
.map(m) // and use them as indices for the middle part of the string
:+l // append l
)
take i // to handle 0 and 1, take i letters from the result
}
05AB1E , 20 बाइट्स
èā¨¨₂и¾šηε{®ª}0šδè¹ù
अतिरिक्त दूसरे इनपुट के रूप में शब्दों की सूची लेता है।
वर्णों की सूची के रूप में आउटपुट।
यह ऑनलाइन का प्रयास करें या सभी को सत्यापित \$[0,99]\$परीक्षण के मामले ।
स्पष्टीकरण:
è # Index the (implicit) input-integer into the (implicit) string-list
ā # Push a list in the range [1,string-length] (without popping)
¨¨ # Remove the last two values to make the range [1,length-2]
₂и # Repeat this list 26 times: [1,2,3] → [1,2,3,1,2,3,1,2,3,...]
¾š # Prepend a 0 to this list
η # Take all prefixes
ε # Map each prefix-list to:
{ # Sort the list
®ª # And append a -1
}0š # After the map: prepend a 0 to the list of lists
δ # Map over each list:
è # Index it in the string that's still on the stack
# (modulair 0-based, so the -1 indexes into the last character)
¹ù # Keep the list of characters of a length equal to the first input
# (after which the result is output implicitly as result)
यदि एक आलसी अनंत परिणाम का उत्पादन करने की अनुमति है, तो इसके बजाय -1 बाइट के लिए ₂иहो सकता है Þ: इसे ऑनलाइन आज़माएं ।
फैक्टर , 201 बाइट्स
: s ( n d -- s ) dupd 2dup nth length 2 - pick 1 - 1 max dup [ / ] dip swap
<repetition> dup first [ + ] accumulate [ 1 + >integer ] map nip [ nth ] dip
dupd swap nths [ 1 head ] dip append swap head ;
इसे ऑनलाइन आज़माएं!
जाप , 25 बाइट्स
gV
_uUÊ-2 Ä}hV[0UÊÉ] Í®gU
कोशिश करो
Input :
U = dictionary
V = number
gV - get element from dictionary
hV[0UÊÉ] - build a list of V indexes,
starting with [0 , last idx]
and calling the following function on last element to generate next items.
_uUÊ-2 Ä} - returns number modulo( literal length -2) + 1
Example : 11 - eleven
[0,5] -> 5%4+1
[0,5,2] -> 2%4+1
[0,5,2,3]
[0,5,2,3,4,1,..]
ͮgU - sort and maps to literal
-P flag to join result