Maintenant que nous savons comment bien carré et triangle un certain nombre, nous allons apprendre à parallélogramme un. Pour parallélogrammer un nombre, nous l'arrangons d'abord comme un parallélogramme en l'empilant au-dessus de lui-même un nombre de fois égal au nombre de chiffres qu'il a, et en ajoutant des espaces pour en faire un parallélogramme. Ainsi 123se formerait:

   123
  123
 123

Maintenant, nous prenons chaque nombre horizontal et vertical et les additionnons 123+123+123+1+12+123+23+3, ce qui équivaut à 531, qui est le parallélogramme de 123.

Ta tâche:

Écrivez un programme ou une fonction qui, une fois donné un nombre en entrée, renvoie le parallélogramme du nombre.

Contribution:

Un entier non négatif ou un entier non négatif représenté par une chaîne.

Production:

Le parallélogramme de l'entier.

Cas de test:

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

Notation:

C'est le code-golf , le score le plus bas en octets gagne!

MATL , 12 octets

tnEXyPY+c!Us

L'entrée est une chaîne. Essayez-le en ligne!

Explication

Considérez l'entrée '123'comme exemple.

Le code duplique l'entrée ( t) et construit une matrice d'identité ( Xy) de taille deux fois la longueur d'entrée ( 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

puis le retourne à l'envers ( 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

La chaîne d'entrée, interprétée comme des codes ASCII des chiffres, équivaut au vecteur de ligne numérique

49 50 51

La convolution bidimensionnelle pleine grandeur ( Y+) du vecteur et de la matrice ci-dessus donne

 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

L'interprétation de ces nombres en tant que codes ASCII ( c) donne la matrice de caractères suivante, avec le caractère 0 représenté comme un espace:

     123
    123 
   123  
  123   
 123    
123

Transposition ( !) transforme cela en

     1
    12
   123
  123 
 123  
123   
23    
3     

Interpréter chaque ligne comme un nombre ( U) donne le vecteur de colonne numérique

  1
 12
123
123
123
123
 23
  3

et la somme qu'il ( s) donne le résultat final, 531.

Rétine , 22 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication: La première étape divise le numéro d'entrée à chaque chiffre et inclut tous les préfixes exclusifs et suffixes inclusifs, donnant les numéros verticaux, ainsi que le numéro d'entrée d'origine répété pour chaque chiffre, donnant les chiffres horizontaux. Les étapes restantes additionnent alors simplement les nombres résultants.

05AB1E ,  12 11  8 octets

_{Je m » que savait peut pourrait être plus golfed - conseils sont les bienvenus!}

-1 octet grâce à Erik l'Outgolfer (éviter les wraps mais en utilisant une concaténation)
puis ...
-3 octets supplémentaires grâce à Adnan (éviter la multiplication par la longueur-1 en vectorisant l'addition et en soustrayant l'entrée à la fin)

.s¹η++Oα

Essayez-le en ligne!

Comment?

.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 octets

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

Essayez-le en ligne!

Husk , 13 12 octets

ṁit§+SRL§+ḣṫ

Essayez-le en ligne!

Explication

              -- 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 octets

𝐱S𝐗𝔻𝔻𝐬𝕤

Il faut se méfier. Contient des serpents:S𝐬𝕤

Essayez-le en ligne!

Python 3 , 85 70 octets

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

Pour l'entrée 12345:

Récapitule les tranches d'entrée 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345, en utilisant l'indexation des chaînes pour indexer (r) = 1,2,3,4 avant de convertir en entier et ajoute à 12345 * 2

Remerciement spécial à:

-14 octets @Jonathan Allen

-1 Byte @ovs

Essayez-le en ligne!

Japt , 15 11 octets

-4 octets grâce à @Shaggy.

¬£iYç
cUz)x

Prend l'entrée sous forme de chaînes.

Essayez-le en ligne!

Explication

£

Divisez le tableau d'entrée en chiffres ( ¬) et mappez par ( £) la fonction suivante, où Y est l'index.
["1", "2", "3"]

iYç

La valeur d'entrée (implicite) avec des Yespaces ( ç) insérés ( i) au début. Il est affecté à U.
["123", " 123", " 123"]

cUz1)x

Concaténer cela avec lui-même tourné de 90 ° à droite ( 1temps). Puis sum ( x).
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531.

Japt , 31 18 octets

-13 octets grâce à @ETHproductions

Cette approche ne fonctionne pas bien avec Japt. La solution de Justin est bien meilleure.

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

Explication:

[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

Essayez-le en ligne!

Ruby , 61 55 + 1 = 56 octets

Utilise le -ndrapeau. Entrée de STDIN.

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

Essayez-le en ligne!

JavaScript, 77 74 octets

Économie de 3 octets grâce à 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 octets

Mon approche de préfixe actuelle (j'espère jouer au golf plus loin).

+*tlQsQssM+_M.__Q._

Testez Suite ou essayez une autre approche avec le même nombre d'octets .

Explication

+*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.

Pour mieux comprendre le concept, prenons un exemple, disons "123".

• Nous obtenons d'abord les préfixes de l'entrée. Ce sont ['1', '12', '123'].

• Ensuite, nous obtenons les préfixes de l'entrée inversée, c'est-à-dire: ['3', '32', '321']et inversons chacun, d'où nous obtenons ['3', '23', '123'].

• Nous concaténons les deux listes et convertissons chaque élément en un entier, donc nous obtenons [3, 23, 123, 1, 12, 123].

• En sommant la liste, le résultat est 285.

• Le produit Pest la longueur de l'entrée - 1 (ie 2) multipliée par la représentation entière de celle-ci ( 2 * 123 = 246).

• Au final, on additionne les deux résultats 285 + 246:, donc on obtient 531, qui est le bon résultat.

Pyth , 20 octets

+*hlQsQsm+s>Qds<QdtU

Suite de tests.

Explication

Explication à venir après un nouveau golf. Je n'ai pas réussi à jouer au golf plus loin pour l'instant (j'ai des idées cependant).

+*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 octets

Solution:

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

Exemples:

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

Explication:

{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

Gelée , 18 octets

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

Essayez-le en ligne!

Swift 3 , 213 octets

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

Ne peut être testé en ligne, car il est lent et arrive à expiration. Vous pouvez l'essayer dans Swift Playgrounds si vous souhaitez le tester.

Exemple d'exécution

Contribution:

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

Production:

531
417
10288049

Gelée , 12 octets

LḶṚ⁶ẋ;€µ;ZVS

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne. Crée le "parallélogramme" comme une matrice de caractères, puis évalue chaque ligne et colonne pour obtenir la somme des nombres.

Explication

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 octets (78 + -lmdrapeau du compilateur)

Salut! Ceci est ma première soumission, j'espère que je n'ai enfreint aucune règle.

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

Essayez-le en ligne!

Non golfé, sans avertissements:

#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 126 116 114 octets

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 octets (137 → 126 et 116 → 114) grâce à @ OlivierGrégoire .

Explication:

Essayez-le ici.

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 octets

-6 octets en n'utilisant pas c ()

-59 octets grâce à @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}

Essayez-le en ligne!

Prend l'entrée sous forme de chaîne.

Je suis absolument certain qu'il y a des améliorations à apporter, principalement en tirant parti des forces de R ... mais dans un défi qui est essentiellement une manipulation de cordes, j'ai du mal à voir comment.

Edit: Beaucoup mieux maintenant que je ne répète pas une mauvaise idée!

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

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

Essayez-le en ligne!

Mathematica, 77 octets

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