Dimensione um número
Introdução
Dado um número inteiro \$< 100,\$ estender / encurtar a representação em inglês do número para ter tantos caracteres quanto seu valor.
Caixa de areia
Regras
Pegue o número \$n\$e obtenha-o em palavras neste dicionário. Você pode usar este dicionário da maneira que preferir. (uma lista, lida do link, argumento da linha de comando, STDIN, variável, etc.)
Aqui está o arquivo como um array JSON. (Cortesia da Lyxal)
Em seguida, faça o seguinte com a string:
- Se o comprimento da string for menor que o número, repita alguns de seus caracteres no lugar até que o comprimento corresponda ao número.
- O primeiro e o último caracteres não devem ser repetidos e o número de repetições dos outros caracteres deve diferir em no máximo um (então você pode repetir alguns deles 5 vezes e outros 6 vezes, por exemplo; não importa quais exatamente).
- Se o comprimento da string for maior que o número, remova qualquer um de seus caracteres, exceto o primeiro e o último, para fazer com que o comprimento corresponda ao número. 1 e 0 são exceções, pois são muito pequenos.
- A ordem das letras na string deve ser mantida.
- Exemplo:
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
Roteiro passo a passo
Tomando 11 como exemplo,
(formatado como word → length)
eleven → 6
^
elleven → 7
^
elleeven → 8
^
elleevven → 9
^
elleevveen → 10
^
ellleevveen → 11 (end)
Exemplos
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
Critérios de Vencimento
Este é o código de golfe . O código mais curto em cada idioma vence.
Recompensa LoTM reivindicada por Dominic Van Essen!
A primeira resposta de Husk para essa pergunta receberá uma recompensa de +50 rep além da recompensa de Zgarb, se atender aos critérios colocados aqui na parte de esforços adicionais .
Respostas
R , (110 105 96) 96 95 bytes
Espero responder à pergunta correta agora ...
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='')
Experimente online!
Doh! Leia a pergunta, estúpido!
Ok, as primeiras (várias) tentativas não estavam respondendo à pergunta correta, porque não li o desafio corretamente e não percebi que os primeiros + últimos caracteres não deveriam ser repetidos. Coincidentemente, porém, a reescrita quase completa saiu com o mesmo número de bytes!
Quão? Código não-golfe:
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 bytes
d!n|h:t<-d!!n=take n$h:[t!!div(i*length t-i)(n-1)|i<-[1..]]
Experimente online!
Uso: ["zero","one",...]!n.
Por exemplo, para entrada 11, ele produzirá um 'e'seguido por "leven"indexado em: $$ \ left \ lfloor \ frac {4} {10} \ right \ rfloor, \ left \ lfloor \ frac {8} {10} \ right \ rfloor , \ dots, \ left \ lfloor \ frac {40} {10} \ right \ rfloor $$ que é "lleevvveen". (Intuitivamente, a fórmula aumenta os índices [0..4] de "leven"[0..10].)
take n$é usado para suportar o caso 0 (caso contrário, a saída é "z"), mas também nos permite escrever em [1..]vez de [1..n-1], portanto, o custo líquido é de apenas 4 bytes em vez de 7.
Husk , 28 27 25 22 21 bytes
Edit: -2 bytes graças a Zgarb, -3 bytes a mais graças a Jo King e então -1 byte mais graças novamente a Zgarb (os últimos 4 bytes demoraram um pouco para trabalhar e entender; eu adicionei uma explicação, mas não é fácil para novatos Husk como eu ...)
SṀ!(O↑¹:1S:ȯ*¹…2←L)!→
Experimente online!
Minha primeira resposta do Husk , inspirada na 'linguagem do mês'.
Porto da abordagem em minha resposta R .
Estou muito feliz em descobrir como escrever um programa de trabalho (hooray!), Então quase certamente não é tão divertido quanto poderia ser ...
Quão? (comentado depois dos campos de golfe de Zgarb & Jo King: é bastante complicado agora ...):
Em primeiro lugar, colocaremos todos os argumentos implícitos (como sobrescritos ⁰e ²):
SṀ!(O↑²:1S:ȯ*²…2←L)!→²⁰
Agora o código comentado:
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
Jelly , 20 bytes
ị©L⁸,_2œs/Ẉ⁸>Ø.¤j®x"
Um link diádico que aceita o número à esquerda e a lista de nomes de números à direita (na ordem do índice Jelly), que produz uma lista de caracteres.
Experimente online! Ou veja todos os 100 .
Quão?
ị©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 bytes
[{.[(]#~1:0 _1}2+/@}.($[:}:@}.@=#\))>@{
Experimente online!
Python 3 , 98 bytes
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]
Experimente online!
-8 bytes graças a ovs
-2 bytes graças a pxeger
(-9 bytes entre os dois porque um dos bytes salvos se sobrepõe entre as duas otimizações)
-9 bytes a mais graças ao ovs
JavaScript (ES6), 78 73 bytes
Espera (n)(dictionary). Retorna uma string vazia para 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)
Experimente online!
K (ok) , 50 46 40 bytes
-4 bytes graças a ovs
-6 bytes graças a coltim
{x#,/(1,(+/'(-2+#y@x;0N)#2_x#1),1)#'y@x}
Experimente online!
Ferrugem, 203 bytes
|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)}
Experimente online
Um fechamento do tipo fn(usize,&mut [Vec<char>]). O resultado está escrito em a[i].
APL (Dyalog Unicode) , 39 37 36 bytes
-2 bytes graças a Razetime !
-1 byte graças a Jo King !
Assume ⎕IO←0.
⊃∘⌷{⍵↑⍺/⍨1,⍨1,(⍵-2)(⌊÷+|⍨>∘⍳⊢)≢2↓⍺}⊣
Experimente online!
Explicação
Esta função recebe o dicionário como o argumento direito e o inteiro como o argumento esquerdo.
⊃∘⌷é uma função que obtém a palavra no índice esquerdo do dicionário direito.
⊣é a função de identidade esquerda.
A função interna { ... }é então chamada com a palavra como argumento à esquerda ⍺e o inteiro como argumento à direita ⍵.
≢2↓⍺é o comprimento da palavra sem os dois primeiros caracteres ( a).
⍵-2é apenas a entrada de número inteiro menos 2( b).
Com esses dois argumentos, a função ⌊÷+|⍨>∘⍳⊢é chamada:
⍳⊢cria um vetor de índice 0 1 ... a-1.
|⍨calcula b mod a.
>compara isso com o vetor de índice, que resulta em um vetor booleano com b mod a 1'se a - b mod a 0' s.
⌊÷é o chão de b÷a.
+adiciona isso ao vetor booleano.
1,prepends um 1, 1,⍨acrescenta um 1.
⍺/vseleciona tantos itens da palavra x, conforme indicado em v. Exemplo: 1 3 2 2 2 1/'eleven'≡'ellleevveen'. Isso é comutado ( ⍨) aqui para evitar colchetes.
⍵↑em seguida, obtém o número necessário de caracteres. Isso é necessário para 0e 1.
Carvão , 29 bytes
ＮθＦ⊕θＳηＦθ§η∧ι⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹
Experimente online! O link é para a versão detalhada do código. Aceita a entrada como o número e, em seguida, o dicionário. A remoção dos Ｆ⊕θＳηresultados em um programa que redimensiona a segunda linha para o comprimento fornecido na primeira linha. Irritantemente, 2foi o número mais difícil de processar, já que tanto o primeiro quanto o último caractere são casos extremos. Explicação:
Ｎθ
Entrada n.
Ｆ⊕θＳη
Leia no dicionário até e incluindo a entrada para n.
Ｆθ
Faça um loop sobre os npersonagens. ( ⭆θtambém funciona.)
§η
Produza o caractere da palavra do dicionário fornecida pelo índice calculado.
∧ι
Para o primeiro caractere da saída, o índice calculado é sempre 0.
⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹
Caso contrário, dimensione a distância até o final da string de 0..n-2a 0..l-2(onde lé o comprimento da palavra do dicionário), arredondado para cima. Observe que isso resulta em 0/0for n=2, portanto, o denominador é forçado a 1neste caso. Exemplo para 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
Portanto, os índices de saída estão 0, 1, 1, 2, 3resultando em fiive. (Na verdade, os cálculos são feitos usando índices negativos, então os índices reais são 0, -3, -3, -2, -1, o que significa que eles são arredondados para baixo, em vez de para cima.)
Perl 5 , 77 bytes
sub{@w=@{$d[$n=pop]};$h=$n<4?2:(@w-2)/($n-2);join'',@w[map.99+$h*$_,0..$n-1]}
Experimente online!
Scala, 93 bytes
i=>a=>{val f+:m:+l=a(i);(f+:Seq.fill(i)(m.indices).flatten.take(i-2).sorted.map(m):+l)take i}
Experimente online!
Define uma função do tipo Int=>Seq[Seq[Char]]=>Seq[Char].
Explicação:
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 bytes
èā¨¨₂и¾šηε{®ª}0šδè¹ù
Usa a lista de palavras como segunda entrada adicional.
Saídas como uma lista de caracteres.
Experimente online ou verifique tudo \$[0,99]\$casos de teste .
Explicação:
è # 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 a saída de um resultado infinito preguiçoso for permitida, o ₂иpoderia ser Þpara -1 byte: tente online .
Fator , 201 bytes
: 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 ;
Experimente online!
Japt , 25 bytes
gV
_uUÊ-2 Ä}hV[0UÊÉ] Í®gU
Tente
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