Dimensionner un nombre

Question

Intro

Étant donné un nombre entier \$< 100,\$ étendre / raccourcir la représentation anglaise du nombre pour avoir autant de caractères que sa valeur.

bac à sable

Règles

Prenez le numéro \$n\$, et obtenez-le dans les mots de ce dictionnaire. Vous pouvez utiliser ce dictionnaire comme vous le souhaitez. (une liste, lue à partir du lien, la ligne de commande arg, STDIN, variable, etc.)

Voici le fichier sous forme de tableau JSON. (Gracieuseté de Lyxal)

Ensuite, procédez comme suit avec la chaîne:

• Si la longueur de la chaîne est inférieure au nombre, répétez certains de ses caractères jusqu'à ce que la longueur corresponde au nombre.
• Le premier et le dernier caractères ne doivent pas être répétés et le nombre de répétitions des autres caractères doit différer d'au plus un (vous pouvez donc répéter certains d'entre eux 5 fois et d'autres 6 fois, par exemple; peu importe lesquels exactement).
• Si la longueur de la chaîne est supérieure au nombre, supprimez l'un de ses caractères à l'exception du premier et du dernier pour que la longueur corresponde au nombre. 1 et 0 sont des exceptions, car ils sont trop petits.
• L'ordre des lettres dans la chaîne doit être conservé.
• Exemple:

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

Parcours étape par étape

Prenant 11 comme exemple,

(formaté comme word → length)

eleven → 6
 ^
elleven → 7
   ^
elleeven → 8
     ^
elleevven → 9
       ^
elleevveen → 10
  ^
ellleevveen → 11 (end)

Exemples

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ères gagnants

C'est du code-golf . Le code le plus court dans chaque langue l'emporte.

LoTM Bounty réclamé par Dominic Van Essen!

La première réponse de Husk à cette question obtiendra une prime de +50 de ma part en plus de la prime de Zgarb, si elle satisfait aux critères énoncés ici dans la partie Efforts supplémentaires .

Answer 1

R , (110105 96) 96 95 octets

J'espère répondre maintenant à la bonne question ...

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='')

Essayez-le en ligne!

Doh! Lisez la question, stupide!

Ok, les premières (plusieurs) tentatives ne répondaient pas à la bonne question, car je n'ai pas lu le défi correctement et je n'ai pas remarqué que les premiers + derniers caractères ne devaient pas être répétés. Par coïncidence, cependant, la réécriture presque complète est sortie au même nombre d'octets!

Comment? Code non golfé:

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.

Answer 2

Haskell , 59 octets

d!n|h:t<-d!!n=take n$h:[t!!div(i*length t-i)(n-1)|i<-[1..]]

Essayez-le en ligne!

Utilisation: ["zero","one",...]!n.

Par exemple, pour l'entrée 11, il affichera un 'e'suivi d'un "leven"indexé à: $$ \ left \ lfloor \ frac {4} {10} \ right \ rfloor, \ left \ lfloor \ frac {8} {10} \ right \ rfloor , \ dots, \ left \ lfloor \ frac {40} {10} \ right \ rfloor $$ qui est "lleevvveen". (Intuitivement, la formule étire les indices [0..4] de "leven"[0..10].)

take n$est utilisé pour prendre en charge le cas 0 (sinon la sortie est "z"), mais il nous permet également d'écrire à la [1..]place de [1..n-1], donc le coût net n'est que de 4 octets au lieu de 7.

Answer 3

Enveloppe , 28 27 25 22 21 octets

Edit: -2 octets grâce à Zgarb, -3 octets de plus grâce à Jo King, puis -1 octet de plus grâce à nouveau à Zgarb (ces 4 derniers octets ont mis un certain temps à travailler et à comprendre; j'ai ajouté une explication mais ce n'est pas facile pour les débutants Husk comme moi ...)

SṀ!(O↑¹:1S:ȯ*¹…2←L)!→

Essayez-le en ligne!

Ma première réponse Husk , inspirée du «langage du mois».
Port de l'approche dans ma réponse R .
Je suis plutôt heureux de savoir comment écrire un programme de travail (hourra!), Donc ce n'est presque certainement pas aussi golfique que cela pourrait être ...

Comment? (commenté après les golfs de Zgarb & Jo King: c'est assez compliqué maintenant ...):

Tout d'abord, nous allons insérer tous les arguments implicites (en exposant ⁰et ²):

SṀ!(O↑²:1S:ȯ*²…2←L)!→²⁰

Maintenant le code commenté:

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

Answer 4

Gelée , 20 octets

ị©L⁸,_2œs/Ẉ⁸>Ø.¤j®x"

Un lien dyadique acceptant le nombre à gauche et la liste des noms-nombres à droite (dans l'ordre d'index Jelly), ce qui donne une liste de caractères.

Essayez-le en ligne! Ou voir les 100 .

Comment?

ị©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

Answer 5

J , ⁴⁰ 39 octets

[{.[(]#~1:0 _1}2+/@}.($[:}:@}.@=#\))>@{

Essayez-le en ligne!

Answer 6

Python 3 , 98 octets

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]

Essayez-le en ligne!

-8 octets grâce à ovs
-2 octets grâce à pxeger

(-9 octets entre les deux car l'un des octets enregistrés chevauche les deux optimisations)

-9 octets de plus grâce aux ovs

Answer 7

JavaScript (ES6),  78  73 octets

Attend (n)(dictionary). Renvoie une chaîne vide pour zéro.

n=>d=>(s=d[n--],g=k=>k<n?s[~k?k/~-n*(s.length-2)+1|0||2:0]+g(k+1):'')(-1)

Essayez-le en ligne!

Answer 8

K (oK) , 50 46 40 octets

-4 octets grâce aux ovs

-6 octets grâce à coltim

{x#,/(1,(+/'(-2+#y@x;0N)#2_x#1),1)#'y@x}

Essayez-le en ligne!

Answer 9

Rouille, 203 octets

|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)}

Essayez-le en ligne

Une fermeture de type fn(usize,&mut [Vec<char>]). Le résultat est écrit a[i].

Answer 10

APL (Dyalog Unicode) , 39 37 36 octets

-2 octets grâce à Razetime !
-1 octet grâce à Jo King !

Suppose ⎕IO←0.

⊃∘⌷{⍵↑⍺/⍨1,⍨1,(⍵-2)(⌊÷+|⍨>∘⍳⊢)≢2↓⍺}⊣

Essayez-le en ligne!

Explication

Cette fonction prend le dictionnaire comme argument de droite et l'entier comme argument de gauche.

⊃∘⌷est une fonction qui récupère le mot à l'index de gauche dans le dictionnaire de droite.
⊣est la fonction d'identité de gauche.
La fonction interne { ... }est alors appelée avec le mot comme argument de gauche ⍺et l'entier comme argument de droite ⍵.

≢2↓⍺est la longueur du mot sans les deux premiers caractères ( a).
⍵-2est juste l'entrée entière moins 2( b).

Avec ces deux arguments, la fonction ⌊÷+|⍨>∘⍳⊢est appelée:
⍳⊢crée un vecteur d'index 0 1 ... a-1.
|⍨calcule b mod a.
>compare cela au vecteur d'index, ce qui donne un vecteur booléen avec b mod a 1's et a - b mod a 0' s.
⌊÷est le sol de b÷a.
+ajoute ceci au vecteur booléen.

1,ajoute a 1, 1,⍨ajoute a 1.
⍺/vsélectionne autant d'éléments du mot x, comme indiqué dans v. Exemple: 1 3 2 2 2 1/'eleven'≡'ellleevveen'. Ceci est commuté ( ⍨) ici pour éviter les crochets.
⍵↑prend alors le nombre de caractères requis. Ceci est nécessaire pour 0et 1.

Answer 11

Charbon , 29 octets

ＮθＦ⊕θＳηＦθ§η∧ι⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Prend l'entrée comme nombre, puis le dictionnaire. Suppression des Ｆ⊕θＳηrésultats dans un programme qui redimensionne la deuxième ligne à la longueur indiquée sur la première ligne. Malheureusement, 2c'était le nombre le plus difficile à traiter, car le premier et le dernier caractère sont des cas extrêmes. Explication:

Ｎθ

Entrée n.

Ｆ⊕θＳη

Lisez dans le dictionnaire jusqu'à et y compris l'entrée pour n.

Ｆθ

Boucle sur les npersonnages. ( ⭆θfonctionne également.)

§η

Affiche le caractère du mot du dictionnaire donné par l'index calculé.

∧ι

Pour le premier caractère de la sortie, l'indice calculé est toujours 0.

⊖÷×⊕⁻ιθ⁻²Ｌη∨⁻²θ¹

Sinon, mettez à l'échelle la distance jusqu'à la fin de la chaîne de 0..n-2à 0..l-2(où lest la longueur du mot du dictionnaire), arrondi vers le haut. Notez que cela donne 0/0pour n=2, donc le dénominateur est contraint 1dans ce cas. Exemple pour 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

Par conséquent, les indices de production se 0, 1, 1, 2, 3traduisent par fiive. (En fait, les calculs sont effectués à l'aide d'indices négatifs, donc les indices réels le sont 0, -3, -3, -2, -1, ce qui signifie qu'ils sont en fait arrondis vers le bas, plutôt que vers le haut.)

Answer 12

Perl 5 , 77 octets

sub{@w=@{$d[$n=pop]};$h=$n<4?2:(@w-2)/($n-2);join'',@w[map.99+$h*$_,0..$n-1]}

Essayez-le en ligne!

Answer 13

Scala, 93 octets

i=>a=>{val f+:m:+l=a(i);(f+:Seq.fill(i)(m.indices).flatten.take(i-2).sorted.map(m):+l)take i}

Essayez-le en ligne!

Définit une fonction de type Int=>Seq[Seq[Char]]=>Seq[Char].

Explication:

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
}

Answer 14

05AB1E , 20 octets

èā¨¨₂и¾šηε{®ª}0šδè¹ù

Prend la liste de mots comme deuxième entrée supplémentaire.
Sortie sous forme de liste de caractères.

Essayez-le en ligne ou vérifiez tout \$[0,99]\$cas de test .

Explication:

è                  # 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)

Si la sortie d'un résultat infini paresseux est autorisée, le ₂иpeut être à la Þplace de -1 octet: essayez-le en ligne .

Answer 15

Facteur , 201 octets

: 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 ;

Essayez-le en ligne!

Answer 16

Japt , 25 octets

gV
_uUÊ-2 Ä}hV[0UÊÉ] Í®gU

Essayez-le

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