Jetzt , da wir wissen , wie man richtig Platz und Dreieck eine Zahl ist , werden wir lernen , wie man Parallelogramm. Um eine Zahl zu parallelisieren, ordnen wir sie zunächst als Parallelogramm an, indem wir sie so oft auf sich selbst stapeln, wie es Stellen gibt, und Leerzeichen hinzufügen, um sie zu einem Parallelogramm zu machen. So 123würde sich bilden:

   123
  123
 123

Nun nehmen wir jede horizontale und vertikale Zahl und addieren sie 123+123+123+1+12+123+23+3, was gleich ist 531, was das Parallelogramm von ist 123.

Deine Aufgabe:

Schreiben Sie ein Programm oder eine Funktion, die bei Eingabe einer Zahl das Parallelogramm der Zahl zurückgibt.

Eingang:

Eine nicht negative Ganzzahl oder eine nicht negative Ganzzahl, die durch eine Zeichenfolge dargestellt wird.

Ausgabe:

Das Parallelogramm der ganzen Zahl.

Testfälle:

1234567 -> 10288049
123     -> 531
101     -> 417
12      -> 39

Wertung:

Dies ist Code-Golf , die niedrigste Punktzahl in Bytes gewinnt!

MATL , 12 Bytes

tnEXyPY+c!Us

Die Eingabe ist eine Zeichenfolge. Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe '123'als Beispiel.

Der Code dupliziert die Eingabe ( t) und erstellt eine Identitätsmatrix ( Xy) mit der doppelten Länge der Eingabe ( nE):

1 0 0 0 0 0
0 1 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
0 0 0 0 1 0
0 0 0 0 0 1

dann dreht man es um ( P):

0 0 0 0 0 1
0 0 0 0 1 0
0 0 0 1 0 0
0 0 1 0 0 0
0 1 0 0 0 0
1 0 0 0 0 0

Die Eingabezeichenfolge, die als ASCII-Code der Ziffern interpretiert wird, entspricht dem numerischen Zeilenvektor

49 50 51

Die zweidimensionale Faltung ( Y+) des obigen Vektors und der Matrix in voller Größe ergibt

 0  0  0  0  0 49 50 51
 0  0  0  0 49 50 51  0
 0  0  0 49 50 51  0  0
 0  0 49 50 51  0  0  0
 0 49 50 51  0  0  0  0
49 50 51  0  0  0  0  0

Die Interpretation dieser Zahlen als ASCII-Codes ( c) ergibt die folgende Zeichenmatrix, wobei Zeichen 0 als Leerzeichen dargestellt wird:

     123
    123 
   123  
  123   
 123    
123

Transposition ( !) transformiert dies in

     1
    12
   123
  123 
 123  
123   
23    
3     

Wenn Sie jede Zeile als Zahl interpretieren ( U), erhalten Sie den numerischen Spaltenvektor

  1
 12
123
123
123
123
 23
  3

und Summieren es ( s) ergibt das Endergebnis 531.

Netzhaut , 22 Bytes

.
$`;$&$';$_;
\d+
$*
1

Probieren Sie es online! Link enthält Testfälle. Erläuterung: In der ersten Stufe wird die eingegebene Nummer an jeder Stelle aufgeteilt. Dabei werden alle exklusiven Präfixe und Suffixe einschließlich der vertikalen Nummern sowie die ursprüngliche eingegebene Nummer, die für jede Stelle wiederholt wird, mit den horizontalen Nummern angegeben. Die verbleibenden Stufen summieren dann einfach die resultierenden Zahlen.

05AB1E ,  12 11  8 Bytes

_{Ich bin mir sicher, dass diese Dose noch weiter ausgebaut werden kann - Tipps willkommen!}

-1 Byte dank Erik the Outgolfer (keine Zeilenumbrüche, sondern Verkettung)
und dann ...
-3 weitere Bytes dank Adnan (keine Multiplikation mit Länge-1 durch vektorisierte Addition und Subtraktion der Eingabe am Ende)

.s¹η++Oα

Probieren Sie es online!

Wie?

.s¹η++Oα - implicit input, say i      e.g.  123
.s       - suffixes                         [3,23,123]
  ¹      - push i                           123
   η     - prefixes                         [1,12,123]
    +    - addition of top two              [4,35,246]
     +   - addition (vectorises)            [127,158,369]
      O  - sum                              654
       α - absolute difference abs(123-654) 531
         - implicit print

Haskell , 90 78 76 71 64 63 59 57 Bytes

g x=sum[x+div x(10^a)+mod x(10^a)|(a,_)<-zip[1..]$show x]

Probieren Sie es online!

Husk , 13 12 Bytes

ṁit§+SRL§+ḣṫ

Probieren Sie es online!

Erläuterung

              -- implicit input, say "123"
   §+         -- concatenate the results of the following two functions
     SR       --  ¹repeat the input n times, where n is the result of the next function
       L      --   length                                                  ["123","123"]
        §+   --  ²concatenate the results of the following two functions
          ḣ  --     prefixes                                              ["","1","12","123"]
           ṫ --     suffixes                                              ["123","23","3",""]
              -- inner concatenation                                      ["","1","13","123","123","23","3",""]
              -- outer concatenation                                      ["123","123","","1","13","123","123","23","3",""]
  t           -- all but the first element                                ["123","","1","13","123","123","23","3",""]
ṁ             -- map then sum
 i            --   convert to integer (where "" converts to 0)

Neim , 7 Bytes

𝐱S𝐗𝔻𝔻𝐬𝕤

In acht nehmen. Enthält Schlangen:S𝐬𝕤

Probieren Sie es online!

Python 3 , 85-70 Bytes

f=lambda n,r=1,i=int:n[r:]and i(n[r:])+i(n[:r])+f(n,r+1)+i(n)or i(n)*2

Für Eingabe 12345:

Summiert die Slices der Eingaben 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345, indem die String-Indizierung auf index (r) = 1,2,3,4 verwendet wird, bevor sie in eine Ganzzahl umgewandelt werden und addiert sich zu 12345 * 2

Besonderer Dank an:

-14 Bytes @ Jonathan Allen

-1 Byte @ovs

Probieren Sie es online!

Japt , 15 11 Bytes

-4 Bytes dank @Shaggy.

¬£iYç
cUz)x

Übernimmt die Eingabe als Zeichenfolge.

Probieren Sie es online!

Erläuterung

£

Teilen Sie das Eingabearray in Ziffern ( ¬) und ordnen Sie es mit ( £) der folgenden Funktion zu, wobei Y der Index ist.
["1", "2", "3"]

iYç

Der (implizite) Eingabewert mit YLeerzeichen ( ç), die iam Anfang eingefügt ( ) werden. Dies ist zugeordnet U.
["123", " 123", " 123"]

cUz1)x

Verketten Sie das mit sich selbst um 90 ° nach rechts gedreht ( 1Zeit). Dann summiere ( x).
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531.

Japt , 31 18 Bytes

-13 Bytes dank @ETHproductions

Dieser Ansatz funktioniert mit Japt nicht gut. Justins Lösung ist viel besser.

[U*Ål U¬£tYÃUå+]xx

Erläuterung:

[U*Ål U¬£tYÃUå+]xx
[              ]    // Create a new array
 U*Ål               // Push: Input * Input.slice(1).length()
                    // Push:
      U¬            //   Input, split into chars
        £tY         //   Map; At each char: .substr(Index)
            Uå+     // Push: Cumulative reduce Input; with addition
                xx  // Sum all the items, twice

Probieren Sie es online!

Rubin , 61 55 + 1 = 56 Bytes

Verwendet die -nFlagge. Eingabe von STDIN.

p (1..~/$/).sum{|i|[$_[i,~/$/],$_[0,i],$_].sum &:to_i}

Probieren Sie es online!

JavaScript, 77 74 Bytes

3 Bytes gespart dank Value Ink

f=a=>[...a+a].map((_,b)=>a-=-z.substr((b-=n)>0?b:0,b+n),a*=n=(z=a).length)|a

console.log(f('123'));
console.log(f('101'));
console.log(f('12'));
console.log(f('1234567'));
console.log(f('102033'));

Pyth , 20 19 Bytes

Mein aktueller Präfix-Ansatz (wird hoffentlich weiter Golf spielen).

+*tlQsQssM+_M.__Q._

Test Suite oder versuchen Sie einen alternativen Ansatz mit derselben Byte-Anzahl .

Erläuterung

+*tlQsQssM+_M.__Q._  - Full program that reads a String from STDIN, with implicit input.

  tlQ                - Length of the input - 1.
     sQ              - The input converted to an integer.
 *                   - Product of the above two elements. We will call this P.
                 ._  - Prefixes of the input.
          +          - Concatenated with:
           _M.__Q    - The prefixes of the reversed input, reversed.
        sM           - Convert each to an integer.
       s             - Sum.
+                    - Addition of the product P and the sum above.

Um das Konzept besser zu verstehen, nehmen wir zum Beispiel ein Beispiel "123".

• Wir bekommen zuerst die Präfixe der Eingabe. Das sind ['1', '12', '123'].

• Dann erhalten wir die Präfixe der umgekehrten Eingabe, dh: ['3', '32', '321'] und jeweils umgekehrt, daher erhalten wir ['3', '23', '123'].

• Wir verketten die beiden Listen und konvertieren jedes Element in eine Ganzzahl, so dass wir erhalten [3, 23, 123, 1, 12, 123] .

• Durch Summieren der Liste erhalten Sie das Ergebnis 285 .

• Das Produkt Pist die Länge der Eingabe - 1 (dh2 ) multipliziert mit der ganzzahligen Darstellung von ( 2 * 123 = 246).

• Am Ende summieren wir die beiden Ergebnisse: 285 + 246Also erhalten wir 531, was das richtige Ergebnis ist.

Pyth , 20 Bytes

+*hlQsQsm+s>Qds<QdtU

Test Suite.

Erläuterung

Erklärung nach weiterem Golfen zu kommen. Das konnte ich vorerst nicht weiter ausbauen (ich habe aber Ideen).

+*hlQsQsm+s>Qds<QdtUQ  - Full program. Reads from STDIN. Q means input, and is implicit at the end.

  hlQ                  - Length of the input + 1.
     sQ                - The input converted to an integer.
 *                     - Multiply the above. We'll call the result P.
        m         tUQ  - Map over [1...length of the input)
          s>Qd         - input[currentItem:] casted to an integer.
              s<Qd     - input[:currentItem] casted to an integer.
         +             - Sum the above.
       s               - Sum the list.
+                      - Add the sum of the list and P.

q / kdb + 34 Bytes

Lösung:

{sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}

Beispiele:

q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"1234567"
10288049
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"123"    
531
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"101"    
417
q){sum"J"$((c#c),c-(!)2*c:(#)x)#\:x}"12"     
39

Erläuterung:

{sum"J"$((c#c),c-til 2*c:count x)#\:x} / ungolfed
{                                    } / lambda function
                                    x  / implicit input
                                 #\:   / apply take (#) to each-left element with the right element
        (                       )      / the left element
                       c:count x       / count length and save in variable c
                     2*                / multiply by 2 (e.g. 6)
                 til                   / range, so 0 1 2 3 4 5
               c-                      / vector subtraction, so 3 2 1 0 -1 -2
         (   )                         / do this together
          c#c                          / 3 take 3, so 3 3 3
              ,                        / join, so 3 3 3 3 2 1 0 - 1 -2          
    "J"$                               / cast this "123", "123", "123" .. "23" to longs
 sum                                   / sum them up and return result

Jelly , 18 Bytes

DµṚ;\U;;\ṖVS+Ḍ×¥L$

Probieren Sie es online!

Schnelle 3 , 213 Bytes

func f(n:String){print((n.characters.count-1)*Int(n)!+(0..<n.characters.count).map{r in Int(n[n.index(n.startIndex,offsetBy:r)..<n.endIndex])!+Int(n[n.startIndex..<n.index(n.endIndex,offsetBy:-r)])!}.reduce(0,+))}

Kann nicht online getestet werden, da es langsam ist und eine Zeitüberschreitung auftritt. Sie können es in Swift Playgrounds ausprobieren, wenn Sie es testen möchten.

Probelauf

Eingang:

f (n: "123")
f (n: "101")
f (n: "1234567")

Ausgabe:

531
417
10288049

Gelee , 12 Bytes

LḶṚ⁶ẋ;€µ;ZVS

Probieren Sie es online!

Übernimmt die Eingabe als Zeichenfolge. Erstellt das "Parallelogramm" als eine Matrix von Zeichen und wertet dann jede Zeile und Spalte aus, um die zu summierenden Zahlen zu erhalten.

Erläuterung

LḶṚ⁶ẋ;€µ;ZVS  Input: string S
L             Length
 Ḷ            Lowered range - [0, 1, ..., len(S)-1]
  Ṛ           Reverse
   ⁶          The char ' ' (space)
    ẋ         Create that many characters of each in the range
     ;€       Prepend each to S
       µ      Begin a new monadic chain
        ;     Concatenate with
         Z    Transpose
          V   Eval each string
           S  Sum

C (gcc) ,95 8481 Bytes (78 + -lmCompiler-Flag)

Hallo! Dies ist meine erste Einreichung, ich hoffe, ich habe keine Regel gebrochen.

g,o,l;f(char*s){l=atoi(s);while(s[o++])g+=l/pow(10,o)+atoi(s+o);return g+l*o;}

Probieren Sie es online!

Ungolfed, ohne Vorwarnung:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int g,o,l;

int f(char *s){
  l = atoi(s);

  while(s[o++]) {
    g+=l/pow(10,o)+atoi(s+o);
  }

  return g+l*o;
}

int main(void){
  printf("%d\n",f("1234567"));
  return 0;
}

Java 8, 147 137 126 116 114 Bytes

n->{Integer l=(n+"").length(),r=n*l,i=0;for(;++i<l*2;)r+=l.valueOf((n+"").substring(i>l?i-l:0,i<l?i:l));return r;}

-13 Bytes (137 → 126 und 116 → 114) dank @ OlivierGrégoire .

Erläuterung:

Probieren Sie es hier aus.

n->{                          // Method with integer as parameter and return-type
  Integer l=(n+"").length(),  //  Length of the input integer
      r=n*l,                  //  Result-integer (starting at `n*l`)
      i=0;                    //  Index-integer (starting at 0)
  for(;++i<l*2;               //  Loop from 0 through two times `l` (exclusive)
    r+=                       //   Add to the result-integer sum:
       l.valueOf((n+"").substring(
                              //    Substring of input, converted to integer:
        i>l?                  //     If `i` is larger than `l`:
         i-l                  //      Substring starting at `i-l`
        :                     //     Else:
         0,                   //      Substring starting at 0
        i<l?                  //     If `i` is smaller than `l`:
         i                    //      Substring ending at `i` (exclusive)
        :                     //     Else:
         l)                   //      Substring ending at `l` (exclusive)
  );                          //  End of loop
  return r;                   //  Return resulting sum
}                             // End of method

R , 168 162 103 Bytes

-6 Bytes ohne Verwendung von c ()

-59 Bytes dank @ Giuseppe

function(n){k=nchar(n)
a=k*strtoi(n)
for(i in 1:k)for(j in i:k)a=a+(i==1|j==k)*strtoi(substr(n,i,j))
a}

Probieren Sie es online!

Übernimmt die Eingabe als Zeichenfolge.

Ich bin mir absolut sicher, dass Verbesserungen vorgenommen werden müssen, vor allem, wenn es darum geht, die Stärken von R zu nutzen.

Edit: Viel besser jetzt, da ich nicht auf eine schlechte Idee iteriere!

Perl 5 , 53 + 1 (-n) = 54 Bytes

$r=$_*(@n=/./g);for$i(@n){$r+=$_+($t=(chop).$t)}say$r

Probieren Sie es online!

Mathematica, 77 Bytes

(s=IntegerDigits@#;t=Length@s;Tr[FromDigits/@Table[s~Take~i,{i,-t,t}]]+t#-#)&