Dimensiona un numero
Intro
Dato un numero intero \$< 100,\$ estendere / accorciare la rappresentazione inglese del numero per avere tanti caratteri quanti sono il suo valore.
Sandbox
Regole
Prendi il numero \$n\$e leggilo a parole da questo dizionario. Puoi prendere questo dizionario nel modo che preferisci. (un elenco, letto dal collegamento, argomento della riga di comando, STDIN, variabile e così via.)
Ecco il file come array JSON. (Cortesia di Lyxal)
Quindi, fai quanto segue con la stringa:
- Se la lunghezza della stringa è inferiore al numero, ripeti alcuni dei suoi caratteri finché la lunghezza non corrisponde al numero.
- Il primo e l'ultimo carattere non devono essere ripetuti e il numero di ripetizioni degli altri caratteri dovrebbe differire al massimo di uno (quindi puoi ripetere alcuni di essi 5 volte e altri 6 volte, ad esempio; non importa quali Esattamente).
- Se la lunghezza della stringa è maggiore del numero, rimuovi tutti i suoi caratteri tranne il primo e l'ultimo per fare in modo che la lunghezza corrisponda al numero. 1 e 0 sono eccezioni, poiché sono troppo piccoli.
- L'ordine delle lettere nella stringa deve essere mantenuto.
- Esempio:
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
Esecuzione passo dopo passo
Prendendo 11 come esempio,
(formattato come word → length)
eleven → 6
^
elleven → 7
^
elleeven → 8
^
elleevven → 9
^
elleevveen → 10
^
ellleevveen → 11 (end)
Esempi
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
Criteri vincenti
Questo è il golf in codice . Il codice più breve in ogni lingua vince.
La taglia LoTM rivendicata da Dominic Van Essen!
La prima risposta di Husk a questa domanda riceverà da me una taglia di +50 ripetizioni in aggiunta alla taglia di Zgarb, se soddisfa i criteri indicati qui nella parte Ulteriori sforzi .
Risposte
R , (110105 96) 96 95 byte
Si spera di rispondere alla domanda corretta ora ...
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='')
Provalo online!
Doh! Leggi la domanda, stupido!
Ok, i primi (diversi) tentativi non hanno risposto alla domanda corretta, perché non ho letto correttamente la sfida e non ho notato che i primi + ultimi caratteri non dovevano essere ripetuti. Casualmente, però, la riscrittura quasi completa è uscita con lo stesso numero di byte!
Come? Codice ungolfed:
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.
Haskell , 59 byte
d!n|h:t<-d!!n=take n$h:[t!!div(i*length t-i)(n-1)|i<-[1..]]
Provalo online!
Uso: ["zero","one",...]!n.
Ad esempio, per l'input 11, verrà emesso un 'e'seguito da "leven"indicizzato in: $$ \ left \ lfloor \ frac {4} {10} \ right \ rfloor, \ left \ lfloor \ frac {8} {10} \ right \ rfloor , \ dots, \ left \ lfloor \ frac {40} {10} \ right \ rfloor $$ che è "lleevvveen". (Intuitivamente, la formula estende gli indici da [0..4] "leven"a [0..10].)
take n$viene utilizzato per supportare il caso 0 (altrimenti l'output è "z"), ma ci consente anche di scrivere al [1..]posto di [1..n-1], quindi il costo netto è di soli 4 byte anziché 7.
Husk , 28 27 25 22 21 byte
Modifica: -2 byte grazie a Zgarb, -3 byte in più grazie a Jo King, e poi -1 byte in più grazie ancora a Zgarb (quegli ultimi 4 byte hanno impiegato un po 'per elaborare e capire; ho aggiunto una spiegazione ma non è facile per i neofiti di Husk come me ...)
SṀ!(O↑¹:1S:ȯ*¹…2←L)!→
Provalo online!
La mia prima risposta di Husk , ispirata alla "lingua del mese".
Porto di approccio nella mia risposta R .
Sono abbastanza felice solo di capire come scrivere un programma funzionante (evviva!), Quindi quasi certamente non è così golfistico come potrebbe essere ...
Come? (commentato dopo i golf di Zgarb e Jo King: è abbastanza complicato ora ...):
Prima di tutto, inseriremo tutti gli argomenti impliciti (come apici ⁰e ²):
SṀ!(O↑²:1S:ȯ*²…2←L)!→²⁰
Ora il codice commentato:
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
Gelatina , 20 byte
ị©L⁸,_2œs/Ẉ⁸>Ø.¤j®x"
Un collegamento diadico che accetta il numero a sinistra e l'elenco dei nomi dei numeri a destra (in ordine di indice Jelly), che fornisce un elenco di caratteri.
Provalo online! Oppure vedi tutti e 100 .
Come?
ị©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
J , 40 39 byte
[{.[(]#~1:0 _1}2+/@}.($[:}:@}.@=#\))>@{
Provalo online!
Python 3 , 98 byte
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]
Provalo online!
-8 byte grazie a ovs
-2 byte grazie a pxeger
(-9 byte tra i due perché uno dei byte salvati si sovrappone tra le due ottimizzazioni)
-9 byte in più grazie a ovs
JavaScript (ES6), 78 73 byte
Aspetta (n)(dictionary). Restituisce una stringa vuota per zero.
n=>d=>(s=d[n--],g=k=>k<n?s[~k?k/~-n*(s.length-2)+1|0||2:0]+g(k+1):'')(-1)
Provalo online!
K (oK) , 50 46 40 byte
-4 byte grazie a ovs
-6 byte grazie a coltim
{x#,/(1,(+/'(-2+#y@x;0N)#2_x#1),1)#'y@x}
Provalo online!
Ruggine, 203 byte
|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)}
Provalo online
Una chiusura di tipo fn(usize,&mut [Vec<char>]). Il risultato è scritto in formato a[i].
APL (Dyalog Unicode) , 39 37 36 byte
-2 byte grazie a Razetime !
-1 byte grazie a Jo King !
Presume ⎕IO←0.
⊃∘⌷{⍵↑⍺/⍨1,⍨1,(⍵-2)(⌊÷+|⍨>∘⍳⊢)≢2↓⍺}⊣
Provalo online!
Spiegazione
Questa funzione accetta il dizionario come argomento di destra e l'intero come argomento di sinistra.
⊃∘⌷è una funzione che ottiene la parola all'indice sinistro del dizionario destro.
⊣è la funzione di identità sinistra.
La funzione interna { ... }viene quindi chiamata con la parola come argomento a sinistra ⍺e il numero intero come argomento a destra ⍵.
≢2↓⍺è la lunghezza della parola senza i primi due caratteri ( a).
⍵-2è solo l'input intero meno 2( b).
Con questi due argomenti ⌊÷+|⍨>∘⍳⊢viene chiamata la funzione :
⍳⊢crea un vettore indice 0 1 ... a-1.
|⍨calcola b mod a.
>confronta questo con il vettore indice, che risulta in un vettore booleano con b mod a 1'se a - b mod a 0' s.
⌊÷è il pavimento di b÷a.
+aggiunge questo al vettore booleano.
1,antepone a 1, 1,⍨aggiunge a 1.
⍺/vseleziona tanti elementi dalla parola x, come indicato in v. Esempio: 1 3 2 2 2 1/'eleven'≡'ellleevveen'. Questo è commuted ( ⍨) qui per evitare le parentesi.
⍵↑quindi prende il numero di caratteri richiesto. Questo è necessario per 0e 1.
Carboncino , 29 byte
ＮθＦ⊕θＳηＦθ§η∧ι⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹
Provalo online! Il collegamento è alla versione dettagliata del codice. Prende l'input come numero e poi il dizionario. Rimuovere i Ｆ⊕θＳηrisultati in un programma che ridimensiona la seconda riga alla lunghezza indicata sulla prima riga. Fastidiosamente, 2era il numero più difficile da elaborare, poiché sia il primo che l'ultimo carattere sono casi limite. Spiegazione:
Ｎθ
Input n.
Ｆ⊕θＳη
Leggi nel dizionario fino a includere la voce per n.
Ｆθ
Ripeti i ncaratteri. ( ⭆θfunziona anche.)
§η
Emette il carattere della parola del dizionario data dall'indice calcolato.
∧ι
Per il primo carattere dell'output l'indice calcolato è sempre 0.
⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹
Altrimenti scala la distanza dalla fine della stringa da 0..n-2a 0..l-2(dove lè la lunghezza della parola del dizionario), arrotondata per eccesso. Nota che questo si traduce in 0/0per n=2, quindi 1in questo caso il denominatore è forzato . Esempio per 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
Pertanto gli indici di output 0, 1, 1, 2, 3risultano fiive. (In realtà i calcoli vengono eseguiti utilizzando indici negativi, quindi gli indici effettivi lo sono 0, -3, -3, -2, -1, il che significa che sono effettivamente arrotondati per difetto, anziché per eccesso).
Perl 5 , 77 byte
sub{@w=@{$d[$n=pop]};$h=$n<4?2:(@w-2)/($n-2);join'',@w[map.99+$h*$_,0..$n-1]}
Provalo online!
Scala, 93 byte
i=>a=>{val f+:m:+l=a(i);(f+:Seq.fill(i)(m.indices).flatten.take(i-2).sorted.map(m):+l)take i}
Provalo online!
Definisce una funzione di tipo Int=>Seq[Seq[Char]]=>Seq[Char].
Spiegazione:
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 byte
èā¨¨₂и¾šηε{®ª}0šδè¹ù
Accetta l'elenco di parole come secondo input aggiuntivo.
Emette un elenco di caratteri.
Provalo online o verifica tutto \$[0,99]\$casi di test .
Spiegazione:
è # 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)
Se è consentito l'output di un risultato infinito pigro, ₂иpotrebbe essere Þinvece per -1 byte: provalo online .
Fattore , 201 byte
: 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 ;
Provalo online!
Japt , 25 byte
gV
_uUÊ-2 Ä}hV[0UÊÉ] Í®gU
Provalo
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