Personne ne connaît les numéros GAU

22

Permettez-moi de vous présenter les numéros GAU

GAU(1) = 1  
GAU(2) = 1122  
GAU(3) = 1122122333  
GAU(4) = 11221223331223334444  
GAU(6) = 11221223331223334444122333444455555122333444455555666666  
...  
GAU(10) = 11221223331223334444122333444455555122333444455555666666122333444455555666666777777712233344445555566666677777778888888812233344445555566666677777778888888899999999912233344445555566666677777778888888899999999910101010101010101010

Ce défi est assez simple!

Étant donné un entier n> 0, trouver le nombre de chiffres de GAU (n)

Exemple

Faisons GAU (4),
nous prenons les mesures suivantes (jusqu'à ce que nous arrivions à 4) et les concaténons 

[1][122][122333][1223334444]

vous devez écrire chaque nombre autant de fois que sa valeur, mais vous devez compter chaque fois à partir de 1

Essayons de faire GAU (5)
il faudra compter de 1 à 1

[1]

puis de 1 à 2 (mais en répétant chaque nombre autant de fois que sa valeur ) 

[122]

puis de 1 à 3 

[122333]

puis de 1 à 4 

[1223334444]

et enfin de 1 à 5 (c'est la dernière étape car on veut trouver GAU ( 5 )) 

[122333444455555]

Maintenant, nous prenons toutes ces étapes et les concaténons,
le résultat est GAU (5) 

11221223331223334444122333444455555

Nous sommes intéressés par le nombre de chiffres de ces numéros GAU.

Cas de test

Entrée⟼Sortie 

n   ⟼ Length(GAU(n))

1   ⟼ 1  
2   ⟼ 4  
3   ⟼ 10  
10  ⟼ 230   
50  ⟼ 42190  
100 ⟼ 339240  
150 ⟼ 1295790

Il s'agit d'un défi de code-golf .
Le code le plus court en octets gagnera.

Si vous avez encore des questions, faites-le moi savoir.
Je veux vraiment que tout le monde ici comprenne ce schéma complexe magique caché

code-golf  sequence 
4
Que signifie GAU?
— Leaky Nun
21
G est pour GAU, A et U sont là sans raison
2
Jusqu'à n = 9, les longueurs sont des nombres tétraédriques, mais au-delà, les nombres à plusieurs chiffres gênent une forme fermée simple
— Miff
Pour votre information, votre cas de test dit n ⟼ Length(GUA(n)), pas GAU (n).
— numbermaniac
2
@numbermaniac merci d'avoir repéré cela. Les numéros GUA sont totalement différents. Ils n'ont pas encore été inventés!

Réponses:

14

SOGL V0.12 , 11 10 8 7 5 octets

∫∫l*+

Essayez-le ici! - ceci s'attend à être appelé en fonction avec l'entrée sur la pile et la boîte d'entrée vide.
Alternative de 7 octets prenant l'entrée de la zone de saisie:

0.∫∫l*+

Essayez-le ici!

0      push 0
 .     push the input
  ∫    iterate over a range 1..POP (input) inclusive, pusing the current number
   ∫    iterate over 1..POP (above loops number) inclusive, pusing the current number
    l    push that numbers length without popping the number
     *   multiply the length by the number
      +  add to the zero, or whatever it is now
— dzaima
source
push that numbers length without popping the numbernice
— Erik the Outgolfer
7

Brain-Flak , 166 octets

<>(((()()())({}){})())<>{({}[()]<({}({}<<>({}[()])((){[()](<()>)}{}){{}((((({})({})){}{}){}))<>(({}<({}())>){()<({}[({})])>}{})(<>)}{}<>>({}({})())))>)}{}({}<{}{}{}>)

Essayez-le en ligne!

Explication

<>(((()()())({}){})())<>           # Initialize second stack with 9 and 10
{({}[()]<                          # Do main loop n times:
  ({}
    ({}
      <
        <>({}[()])                 # Subtract 1 from counter to next power of 10
        ((){[()](<()>)}{}){        # If reached a power of 10 (say, 10^k):
          {}((((({})({})){}{}){})) # Multiply existing (10^k*0.9) by 10 and push twice
          <>                       # On first stack
          (
            ({}<({}())>)           # Increment length of numbers
            {()<({}[({})])>}{}     # Divide length of new set of numbers by this length
          )                        # Add together to get new set of numbers length
        (<>)}  
      {}<>>  
      ({}({})())                   # Add number length to number set length
    )                              # Add number set length to new segment length
  )                                # Add new segment length to total length
>)}                                # End main loop
{}({}<{}{}{}>)                     # Put result on stack by itself
— Nitrodon
source
3

Husk , 7 octets

Σ∫mS*Lḣ

Essayez-le en ligne!

Non golfé / Explication

         -- implicit input N                        | 10
  m   ḣ  -- map the following function over [1..N]  | [1,2,3,4]
   S*L   --   multiply length of number by itself   | [1,2,3,4] (only important for numbers ≥ 10)
 ∫       -- prefix sums                             | [0,1,3,6,10]
Σ        -- sum                                     | 20
— ბიმო
source
3

Husk , 7 octets

ṁLṁṘNḣḣ

Essayez-le en ligne!

Explication

          Implicit input, e.g 4
      ḣ   Range from 1 to n                               [1,2,3,4]
     ḣ    Prefixes                                        [[],[1],[1,2],[1,2,3],[1,2,3,4]]
  ṁ       Map and then concatenate
   ṘN     Repeat each number in each list by its index    [[],[1],[1,2,2],[1,2,2,3,3,3],[1,2,2,3,3,3,4,4,4,4]]
                                                          [1,1,2,2,1,2,2,3,3,3,1,2,2,3,3,3,4,4,4,4]
ṁ         Map and then sum
 L        Length (of number: 10 -> 2)                     26
— H.PWiz
source
Oh une autre solution Husk :) Vous n'avez pas vu votre soumission lors de la publication de la mienne, même bytecount mais ils sont suffisamment différents, alors je vais laisser la mienne ici aussi.
— ბიმო
3

CJam , 20 octets

q~),(\{),{_s,*+}*+}%

Essayez-le en ligne!

Le nombre est passé dans le champ "entrée".

Explication non gérée: (exemple d'entrée = 2)

q~),(\{),{_s,*+}*+}%                                             | Stack:
q                     read input as string                       | "2"
 ~                    eval input (add it to stack as integer)    | 2
  )                   add 1                                      | 3
   ,                  range (convert to array with values 0...N) | [0, 1, 2]
    (                 pop first item of array                    | [1, 2] 0
     \                swap top two values of stack               | 0 [1, 2]
      {           }   for each item in array...                  | 0 1
       )              add 1                                      | 0 2
        ,             range (convert to array with values 0...N) | 0 [0, 1]
         {     }      for every element in the array...          | 0 0
          _           duplicate                                  | 0 0 0
           s          convert to string                          | 0 0 "0"
            ,         get length of string                       | 0 0 1
             *        multiply                                   | 0 0
              +       add                                        | 0 1
                *     fold                                       | 0 1
                 +    add                                        | 1
                   %  repeat                                     | 4

Cela semble difficile quand on l'explique lol.

— Iaka Noe
source
2

J, 24 octets

[:+/[:+/\[:(*#@":"0)1+i.

Approche de haut niveau similaire à la réponse APL de dzaima, traduite en J, sauf que nous calculons la longueur du nombre en la transformant d'abord en chaîne au lieu de prendre des journaux, et nous pouvons utiliser le crochet de J pour multiplier cette longueur par le nombre lui-même: (*#@":"0) . Après cela, c'est juste la somme de la somme du scan.

Essayez-le en ligne!

— Jonas
source
1
1(#.]*#\*#\.)1#@":@+i.fonctionne également pendant 22 octets
— miles
@miles C'est intelligent - il m'a fallu un peu de temps pour le comprendre. Depuis combien de temps programme-t-on en J?
— Jonah
Un peu après avoir rejoint code-golf. Je ne l'utilise pas pour écrire de vrais programmes car je ne sais pas le lire, mais je l'utilise maintenant comme une calculatrice de bureau avancée et j'ai généralement une fenêtre ouverte pour calculer quelque chose.
— miles
2

R , 39 octets

function(n)sum(nchar(rep(1:n,n:1*1:n)))

Vérifiez tous les cas de test!

Algorithme simple; J'ai observé, comme la plupart l'ont fait, que pour iin 1:n, ic'est répété des i*(n-i+1)fois. Je crée donc ce vecteur, compte le nombre de caractères dans chacun et les additionne.

— Giuseppe
source
1

Python 2, 51 50 octets

lambda n:sum(~k*(k-n)*len(`k+1`)for k in range(n))
— orlp
source
@LeakyNun Pourquoi? J'ai développé cette réponse moi-même. Je n'ai même pas vérifié les autres réponses.
— orlp
1
Cela ne donne même pas la bonne réponse, donne 0 pour n = 1, 3 pour n = 2 et 14 pour n = 3
— Halvard Hummel
@HalvardHummel Oups, foiré un signe et oublié un +1. Fixé maintenant.
— orlp
Je vois que tu as enfin compris le patern! Existe-t-il un moyen de tester votre code en ligne ou l'autre réponse Python 2 couvre également cela?
1

JavaScript (ES6), 50 42 octets

Mise à jour: maintenant essentiellement un portage de ce que font les autres réponses.

f=(n,i=1)=>n&&`${n}`.length*n*i+f(n-1,i+1)

Cas de test

Afficher l'extrait de code

— Arnauld
source
1

Mathematica, 66 octets

Tr[1^(f=Flatten)[IntegerDigits/@f@(a=Array)[a[#~Table~#&,#]&,#]]]&
— J42161217
source
1

En fait , 13 octets

R♂R♂i⌠;n⌡Mεjl

Essayez-le en ligne!

Explication:

R♂R♂i⌠;n⌡Mεjl
R              range(1, n+1)
 ♂R            range(1, x+1) for x in previous
   ♂i          flatten into 1D list
     ⌠;n⌡M     for x in list:
      ;n       repeat x x times
          εj   concatenate to string
            l  length
— Mego
source
1

Japt , 12 11 10 9 octets

õõÈ*sÊÃxx

Essayez-le ou testez tous les nombres de 1 à 150 .

Explication

Saisie implicite d'entier U.

õõ

Générez un tableau d'entiers de 1 à Upuis générez des sous-tableaux de 1 à chaque entier.

È   Ã

Passez les éléments de chaque sous-tableau via une fonction.

*sÊ

Convertissez l'élément actuel en chaîne ( s), obtenez sa longueur ( Ê) et multipliez-le par l'élément.

xx

Réduisez le tableau principal par addition après avoir fait la même chose pour chaque sous-tableau.

— Hirsute
source
1

Jq 1.5 , 82 49 43 octets

[range(.)+1|range(.)+1|"\(.)"*.|length]|add

Étendu

[   range(.)+1        # for i=1 to N
  | range(.)+1        # for j=1 to i
  | "\(.)"*.          # "j" copied j times
  | length            # convert to length
] | add               # add lengths

Sample Run

$ jq -Mr '[range(.)+1|range(.)+1|"\(.)"*.|length]|add' <<< "150"
1295790

Essayez-le en ligne! aussi jqplay.org

— jq170727
source
1

Empilé , 28 octets

[~>[~>[:rep]"!]"!flat''#`#']

Essayez-le en ligne!

Certains pourraient demander: "À quel moment les alias sont-ils illisibles?" Si ce n'est pas proche, vous avez une définition très libérale de la "lisibilité".

Explication

[~>[~>[:rep]"!]"!flat''#`#']    input: N
 ~>[          ]"!               for each number K from 1 to N
    ~>[    ]"!                  for each number J from 1 to K
       :rep                     repeat J J times
                 flat           flatten the resultant array
                     ''#`       join by the empty string
                         #'     get the length of said string
— Conor O'Brien
source
1

C # (.NET Core) , 94 80 74 octets

n=>{int b=0,a=0,i;while(a++<n)for(i=0;i++<a;)b+=(i+"").Length*i;return b;}

Essayez-le en ligne!

J'espérais trouver une solution directe comme ce que la réponse de @ kamoroso94 commencé, mais j'ai abandonné car je trop de temps dessus. Il y a probablement un moyen de le faire, mais la formule doit être ajustée pour chaque pas de grandeur.

Remerciements

14 octets économisés grâce à @someone

6 octets économisés grâce à @Kevin Cruijssen

— Ayb4btu
source
1
n=>{int b=0,a=0,i;for(;a++<n;)for(i=0;i++<a;)b+=i.ToString().Length*i;return b;} Essayez-le en ligne! pour 80 octets et performances.
— mon pronom est monicareinstate
1
i.ToString()peut être (i+"")d'économiser quelques octets supplémentaires.
— Kevin Cruijssen
1

MATL , 15 octets

:ttP*Y"10&YlQks

Essayez-le en ligne!

Explication:

:                range 1:input (implicit input)
 tt              duplicate twice
   P             reverse
    *            multiply elementwise
     Y"          runlength decoding
       10&Yl     log10
            Qk   increment and floor
              s  sum (implicit output)
— Giuseppe
source
Ce logarithme coûte cher :-) Vous pouvez le remplacer en le convertissant en chaîne, en supprimant les espaces, la longueur::ttP*Y"VXzn
— Luis Mendo
1

Perl 6 , 36 octets

{[+] 1..*Z*($_...1).map:{.chars*$_}}

Essaye-le

Étendu:

{  # bare block lambda with implicit parameter ｢$_｣

  [+]               # reduce the following using &infix:«+»

    1 .. *          # Range from 1 to infinity

    Z*              # zip using &infix:«*»

    ( $_ ... 1 )    # sequence from the input down to 1
    .map:           # for each one
    { .chars * $_ } # multiply the number of digits with itself
}
— Brad Gilbert b2gills
source
1

Fusain , 18 14 octets

ＩΣＥ⊕ＮΣＥ⊕ι×λＬＩλ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Edit: Utilisation Summ'a sauvé 4 octets. Explication:

  Ｅ⊕Ｎ           Map from 0 to the input (loop variable i)
      Ｅ⊕ι       Map from 0 to i (loop variable l)
            Ｉλ  Cast l to string
           Ｌ    Take the length
         ×λ     Multiply by l
     Σ          Sum the results
 Σ              Sum the results
Ｉ               Cast to string
                Implicitly print
— Neil
source
: | Somme des nombres dans les chaînes lorsque des arguments de chaîne sont fournis
— ASCII uniquement
@ ASCII uniquement Ce n'était pas ça, c'était juste l'impression d'un à la Σplace ...
— Neil
@ ASCII uniquement Aussi, le mieux que je puisse faire Sumest toujours de 18 octets:Print(Cast(Sum(Map(InclusiveRange(1, InputNumber()), Sum(Map(InclusiveRange(1, i), Times(l, Length(Cast(l)))))))));
— Neil
— ASCII uniquement
@ ASCII seulement j'essayé somme de produit , mais qui était 17 octets: ≔⊕ＮθＩΣＥθ×⁻θι×ιＬＩι. Cependant, en utilisant Incrementedau lieu deInclusiveRange raser 4 octets de mon commentaire précédent!
— Neil
1

[Dyalog APL], 22 20 octets

{+/≢¨⍕¨↑,/(/⍨¨⍳¨⍳⍵)}

Essayez-le en ligne!

Explication:

{+/≢¨⍕¨↑,/(/⍨¨⍳¨⍳⍵)}
{                  } anonymous function with right argument named ⍵
                ⍳⍵   range 1 to right arg
              ⍳¨     for each, range 1 to it
             ¨       for each
           /⍨          for each item, repeat right arg left arg times
          (       )  take that and
        ,/           join the sub-arrays together
       ↑             convert from a nested array to a simple array (or something like that, I don't quite understand it :p)
     ⍕¨              convert each number to a char-array (aka string version)
   ≢¨                get length of each
 +/                  sum that together
— dzaima
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.