Niemand kennt die GAU-Nummern

22

Ich möchte Ihnen die GAU-Nummern vorstellen

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

Diese Herausforderung ist ziemlich einfach!

Ermitteln Sie bei einer Ganzzahl n> 0 die Anzahl der Stellen von GAU (n).

Beispiel

Lassen Sie uns GAU (4) machen,
wir machen die folgenden Schritte (bis wir zu 4 kommen) und verketten sie 

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

Sie müssen jede Zahl so oft schreiben, wie sie wert ist, aber Sie müssen jedes Mal von 1 an zählen

Lassen Sie uns versuchen, GAU (5) zu machen,
wir müssen von 1 bis 1 zählen

[1]

dann von 1 bis 2 (aber jede Zahl so oft wiederholen, wie sie wert ist ) 

[122]

dann von 1 bis 3 

[122333]

dann von 1 bis 4 

[1223334444]

und schließlich von 1 bis 5 (dies ist der letzte Schritt, weil wir GAU ( 5 ) finden wollen ) 

[122333444455555]

Jetzt machen wir alle diese Schritte und verketten sie.
Das Ergebnis ist GAU (5). 

11221223331223334444122333444455555

Wir interessieren uns für die Anzahl der Ziffern dieser GAU-Nummern.

Testfälle

Input⟼Output 

n   ⟼ Length(GAU(n))

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

Dies ist eine Code-Golf- Herausforderung.
Der kürzeste Code in Bytes gewinnt.

Wenn Sie noch Fragen haben, lassen Sie es mich bitte wissen.
Ich möchte wirklich, dass jeder hier dieses magisch-versteckte, komplexe Muster versteht

code-golf  sequence 
4
Wofür steht GAU?
— Undichte Nonne
21
G ist für GAU, A und U sind nur ohne Grund da
2
Bis n = 9 sind die Längen tetraedrische Zahlen, aber darüber hinaus stehen die mehrstelligen Zahlen einer einfachen geschlossenen Form im Wege
— Miff
Zu Ihrer Information, Ihr Testfall sagt n ⟼ Length(GUA(n)), nicht GAU (n).
— numbermaniac
2
@numbermaniac danke, dass du das entdeckt hast. GUA-Nummern sind völlig unterschiedlich. Sie wurden noch nicht erfunden!

Antworten:

14

SOGL V0.12 , 11 10 8 7 5 Bytes

∫∫l*+

Probieren Sie es hier aus! - Dies wird voraussichtlich als Funktion aufgerufen, wenn die Eingabe auf dem Stapel und das Eingabefeld leer sind.
7-Byte-Alternative für die Eingabe aus dem Eingabefeld:

0.∫∫l*+

Probieren Sie es hier aus!

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
quelle
push that numbers length without popping the numbernice
— Erik the Outgolfer
7

Brain-Flak , 166 Bytes

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

Probieren Sie es online!

Erläuterung

<>(((()()())({}){})())<>           # 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
quelle
3

Schale , 7 Bytes

Σ∫mS*Lḣ

Probieren Sie es online!

Ungolfed / Erklärung

         -- 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
— ბიმო
quelle
3

Schale , 7 Bytes

ṁLṁṘNḣḣ

Probieren Sie es online!

Erläuterung

          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
quelle
Oh, eine andere Husk-Lösung :) Ich habe Ihre Einsendung beim Posten meiner nicht gesehen, dieselbe bytecount, aber sie sind ausreichend unterschiedlich, also lasse ich meine auch hier.
— 23.
3

CJam , 20 Bytes

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

Probieren Sie es online!

Die Nummer wird im Eingabefeld übergeben.

Ungolfed Erklärung: (Beispiel Eingabe = 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

Es scheint schwer zu sein, wenn es erklärt wird, lol.

— Iaka Noe
quelle
2

J, 24 Bytes

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

Ein ähnlicher Ansatz auf hoher Ebene für die APL-Antwort von dzaima, übersetzt in J, mit der Ausnahme, dass wir die Länge der Zahl berechnen, indem wir sie zuerst in eine Zeichenfolge umwandeln, anstatt Protokolle zu erstellen, und Js Hook verwenden, um diese Länge mit der Zahl selbst zu multiplizieren: (*#@":"0) . Danach ist es nur die Summe der Scan-Summe.

Probieren Sie es online!

— Jona
quelle
1
1(#.]*#\*#\.)1#@":@+i.funktioniert auch für 22 Bytes
— Meilen
@miles Das ist klug - ich habe ein bisschen gebraucht, um es herauszufinden. Wie lange programmieren Sie schon in J?
— Jonah
Ein bisschen nachdem ich zu Code-Golf gekommen bin. Ich verwende es eigentlich nicht, um echte Programme zu schreiben, da ich nicht weiß, dass ich es lesen kann, aber ich verwende es jetzt als fortgeschrittenen Desktop-Rechner und habe normalerweise immer ein Fenster offen, um etwas zu berechnen.
— Meilen
2

R , 39 Bytes

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

Überprüfen Sie alle Testfälle!

Einfacher Algorithmus; Ich beobachtete, wie die meisten tat, dass für iin 1:n, iwiederholt i*(n-i+1)Zeiten. Also erstelle ich diesen Vektor, zähle die Anzahl der Zeichen in jedem und summiere sie.

— Giuseppe
quelle
1

Python 2, 51 50 Bytes

lambda n:sum(~k*(k-n)*len(`k+1`)for k in range(n))
— orlp
quelle
@LeakyNun Warum? Ich habe diese Antwort selbst entwickelt. Ich habe nicht einmal die anderen Antworten überprüft.
— Orlp
1
Dies gibt nicht einmal die richtige Antwort aus, gibt 0 für n = 1, 3 für n = 2 und 14 für n = 3
— Halvard Hummel
@HalvardHummel Ups, ein Schild durcheinander gebracht und eine +1 vergessen. Jetzt behoben.
— Orlp
Ich sehe, dass du das Muster endlich verstanden hast! Gibt es eine Möglichkeit, Ihren Code online zu testen, oder die andere Antwort von Python 2 deckt dies ebenfalls ab?
1

JavaScript (ES6), 50 42 Bytes

Aktualisiert: jetzt im Grunde genommen eine Portierung dessen, was andere Antworten tun.

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

Testfälle

Code-Snippet anzeigen

— Arnauld
quelle
1

Mathematica, 66 Bytes

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

Eigentlich 13 Bytes

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

Probieren Sie es online!

Erläuterung:

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
quelle
1

Japt , 12 11 10 9 Bytes

õõÈ*sÊÃxx

Probieren Sie es aus oder testen Sie alle Zahlen von 1 bis 150 .

Erläuterung

Implizite Eingabe einer Ganzzahl U.

õõ

Generieren Sie ein Array von Ganzzahlen von 1 bis Uund generieren Sie dann Unterarrays von 1 bis zu jeder Ganzzahl.

È   Ã

Leiten Sie die Elemente jedes Unterarrays durch eine Funktion.

*sÊ

Konvertieren Sie das aktuelle Element in einen String ( s), ermitteln Sie dessen Länge ( Ê) und multiplizieren Sie es mit dem Element.

xx

Reduzieren Sie das Hauptarray, indem Sie es zu jedem Unterarray hinzufügen.

— Zottelig
quelle
1

Jq 1,5 , 82 49 43 Bytes

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

Erweitert

[   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

Probelauf

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

Probieren Sie es online! auch jqplay.org

— jq170727
quelle
1

Gestapelt , 28 Bytes

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

Probieren Sie es online!

Einige könnten fragen: "Wann sind Aliase unlesbar?" Wenn dies nicht naheliegt, haben Sie eine sehr liberale Definition von "Lesbarkeit".

Erläuterung

[~>[~>[: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
quelle
1

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

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

Probieren Sie es online!

Ich hatte gehofft, eine direkte Lösung wie die Antwort von @ kamoroso94 zu finden , gab aber auf, da ich zu viel Zeit damit verbrachte. Es gibt wahrscheinlich eine Möglichkeit, dies zu tun, aber die Formel muss für jeden Größenschritt angepasst werden.

Danksagung

14 Bytes gespart dank @someone

Dank @Kevin Cruijssen werden 6 Bytes gespeichert

— Ayb4btu
quelle
1
n=>{int b=0,a=0,i;for(;a++<n;)for(i=0;i++<a;)b+=i.ToString().Length*i;return b;} Probieren Sie es online! für 80 Bytes und Leistung.
— Mein Pronomen ist monicareinstate
1
i.ToString()kann sein (i+""), etwas mehr Bytes zu sparen.
— Kevin Cruijssen
1

MATL , 15 Bytes

:ttP*Y"10&YlQks

Probieren Sie es online!

Erläuterung:

:                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
quelle
Dieser Logarithmus ist teuer :-) Sie können ihn ersetzen, indem Sie ihn in einen String konvertieren, Leerzeichen und Länge entfernen::ttP*Y"VXzn
— Luis Mendo
1

Perl 6 , 36 Bytes

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

Probier es aus

Erweitert:

{  # 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
quelle
1

Holzkohle , 18 14 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Bearbeiten: Mit Summir 4 Bytes gespeichert. Erläuterung:

  Ｅ⊕Ｎ           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
quelle
: | Summiert die Zahlen in den Zeichenfolgen, wenn Zeichenfolgenargumente angegeben werden
— ASCII
@ Nur ASCII Es war nicht das, es wurde nur ein Σstattdessen gedruckt ...
— Neil
@ Nur ASCII Auch das Beste, was ich tun kann, Sumsind immer noch 18 Bytes:Print(Cast(Sum(Map(InclusiveRange(1, InputNumber()), Sum(Map(InclusiveRange(1, i), Times(l, Length(Cast(l)))))))));
— Neil,
— Nur ASCII
@ ASCII-nur habe ich versucht , von Produktsumme , aber das war 17 Byte: ≔⊕ＮθＩΣＥθ×⁻θι×ιＬＩι. Verwenden Sie jedoch Incrementedstatt InclusiveRangeRasuren 4 Bytes aus meinem vorherigen Kommentar!
— Neil
1

[Dyalog APL], 22 20 Bytes

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

Probieren Sie es online!

Erläuterung:

{+/≢¨⍕¨↑,/(/⍨¨⍳¨⍳⍵)}
{                  } 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
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.