Artık bir sayıyı doğru şekilde kare ve üçgenle nasıl oluşturacağımızı bildiğimize göre , bir paralelkenarın nasıl çizileceğini öğreneceğiz. Bir sayının paralelkenarını almak için, ilk olarak, sahip olduğu basamak sayısına eşit sayıda üst üste istifleyerek ve paralelkenar yapmak için boşluklar ekleyerek paralelkenar olarak düzenleriz. Böylece 123:

   123
  123
 123

Şimdi her yatay ve dikey sayıyı alıp 123+123+123+1+12+123+23+3eşitliyoruz 531, yani paralelkenar 123.

Senin görevin:

Giriş olarak bir sayı verildiğinde sayının paralelkenarını döndüren bir program veya işlev yazın.

Giriş:

Negatif olmayan bir tam sayı veya bir dize ile temsil edilen negatif olmayan bir tam sayı.

Çıktı:

Tamsayı paralelkenar.

Test Durumları:

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

puanlama:

Bu kod golf , bayt kazanır en düşük puan!

MATL , 12 bayt

tnEXyPY+c!Us

Girdi bir dizedir. Çevrimiçi deneyin!

açıklama

Girişi '123'örnek olarak ele alalım.

Kod, input ( t) öğesini çoğaltır ve Xygirdi uzunluğunun ( nE) iki katı büyüklüğünde bir kimlik matrisi ( ) oluşturur :

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

sonra baş aşağı çevirir ( 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

Rakamların ASCII kodları olarak yorumlanan giriş dizgisi, sayısal satır vektörüne eşdeğerdir

49 50 51

Y+Yukarıdaki vektör ve matrisin tam boyutlu iki boyutlu evrişimi ( )

 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

Bu sayıları ASCII kodları ( c) olarak yorumladığınızda , char 0 boşluk olarak gösterilen aşağıdaki karakter matrisi verilir:

     123
    123 
   123  
  123   
 123    
123

Transposition ( !) bunu

     1
    12
   123
  123 
 123  
123   
23    
3     

Her satırı bir sayı ( U) olarak yorumlamak sayısal sütun vektörünü verir

  1
 12
123
123
123
123
 23
  3

ve toplanması ( s) son sonucu verir 531,.

Retina , 22 bayt

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Açıklama: İlk aşama, her rakamdaki giriş numarasını böler ve tüm özel önekleri ve kapsayıcı sonekleri içerir, dikey sayılar ve ayrıca her rakam için tekrarlanan orijinal giriş numarasını ve yatay sayılar verir. Kalan aşamalar daha sonra elde edilen sayıları toplar.

05AB1E ,  12 11  8 bayt

_{Ben 'Eminim bunu biliyordu olabilir ayrıca golfed olabilir - ipucu hoş geldiniz!}

Outgolfer Erik sayesinde -1 bayt (sarardan kaçının ancak birleştirme kullanarak)
ve sonra ...
Adnan sayesinde -3 -3 bayt daha (eki vektör ederek ve sonunda girişi çıkararak uzunluk-1 ile çarpmayı önleyin)

.s¹η++Oα

Çevrimiçi deneyin!

Nasıl?

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

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

Çevrimiçi deneyin!

Kabuk , 13 12 bayt

ṁit§+SRL§+ḣṫ

Çevrimiçi deneyin!

açıklama

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

𝐱S𝐗𝔻𝔻𝐬𝕤

Dikkat. Yılan içerir:S𝐬𝕤

Çevrimiçi deneyin!

Python 3 , 85 70 Bayt

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

12345 girişi için:

Tam sayıya dizilmeden önce dizin dizinine (r) = 1,2,3,4 dizgi dizini kullanarak 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345 giriş dilimlerini toplar , ve 12345 * 2'ye ekler

Özellikle ..... 'ya teşekkür:

-14 Bayt @Jonathan Allen

-1 Bayt @ovs

Çevrimiçi deneyin!

Japt , 15 11 bayt

@Shaggy sayesinde -4 bayt.

¬£iYç
cUz)x

Girişi dize olarak alır.

Çevrimiçi deneyin!

açıklama

£

Girdi dizisini sayılara ( ¬) bölün ve £aşağıdaki işlevle ( ) eşleyin, burada Y indekstir.
["1", "2", "3"]

iYç

Başlangıçta Yboşluklar ( ç) eklenmiş (örtük) giriş değeri i. Bu atandı U.
["123", " 123", " 123"]

cUz1)x

Kendisiyle 90 ° sağa ( 1zaman) döndürülmüş olarak birleştirin . Sonra sum ( x).
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531.

Japt , 31 18 bayt

-13 bayt sayesinde @ETHproductions

Bu yaklaşım Japt kullanarak işe yaramıyor. Justin'in çözümü çok daha iyi.

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

Açıklama:

[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

Çevrimiçi deneyin!

Yakut , 61 55 + 1 = 56 bayt

-nBayrağı kullanır . STDIN'den giriş.

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

Çevrimiçi deneyin!

JavaScript, 77 74 bayt

Value Ink sayesinde 3 bayt tasarruf

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 bayt

Mevcut önek yaklaşım (umarım daha da golf olacak).

+*tlQsQssM+_M.__Q._

Suite'i test edin veya aynı bayt sayısı ile alternatif bir yaklaşım deneyin .

açıklama

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

Kavramı daha iyi anlamak için bir örnek alalım "123".

• Öncelikle girişin öneklerini alırız. Bunlar ['1', '12', '123'].

• Sonra, ters girdinin öneklerini alırız, yani: ['3', '32', '321']ve her birini tersine çeviririz, dolayısıyla alırız ['3', '23', '123'].

• İki listeyi birleştiririz ve her öğeyi bir tamsayıya dönüştürürüz, böylece elde ederiz [3, 23, 123, 1, 12, 123].

• Listeyi toplayarak sonuç 285.

• Ürün P, girişin uzunluğu - 1 (yani2 ), tamsayı temsili () ile çarpılır 2 * 123 = 246.

• Sonunda, iki sonucu 285 + 246özetliyoruz : dolayısıyla elde ettiğimiz 531doğru sonuç bu.

Pyth , 20 bayt

+*hlQsQsm+s>Qds<QdtU

Test odası.

açıklama

Daha fazla golf sonrası gelecek açıklama. Şimdilik bu kadar golf başaramadı (olsa da fikirlerim var).

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

Çözüm:

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

Örnekler:

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

Açıklama:

{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

Jöle , 18 bayt

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

Çevrimiçi deneyin!

Swift 3 , 213 bayt

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

Çevrimiçi test edilemez, çünkü yavaş ve zaman aşımına uğramıştır. Test etmek isterseniz Swift Playgrounds'da deneyebilirsiniz.

Örnek çalışma

Giriş:

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

Çıktı:

531
417
10288049

Jöle , 12 bayt

LḶṚ⁶ẋ;€µ;ZVS

Çevrimiçi deneyin!

Girişi dize olarak alır. Bir karakter matrisi olarak "paralelkenar" oluşturur, ardından sayıları toplamak için her satırı ve sütunu değerlendirir.

açıklama

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 bayt (78 + -lmderleyici bayrağı)

Selam! Bu benim ilk görüşüm, umarım herhangi bir kuralı ihlal etmedim.

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

Çevrimiçi deneyin!

Ungolfed, uyarılar olmadan:

#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 bayt

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

@ OlivierGrégoire sayesinde -13 bayt (137 → 126 ve 116 → 114) .

Açıklama:

Burada deneyin.

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 bayt

C () kullanmadan -6 bayt

@Giuseppe sayesinde -59 bayt

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}

Çevrimiçi deneyin!

Girişi dize olarak alır.

Öncelikle R'nin güçlü yönlerinden herhangi birini kullanarak yapılacak iyileştirmeler olacağından kesinlikle eminim ... ama temelde ip manipülasyonu olan bir meydan okumada, nasıl olduğunu görmek için mücadele ediyorum.

Düzenleme: Şimdi kötü bir fikir üzerinde yineleme değil çok daha iyi!

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

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

Çevrimiçi deneyin!

Mathematica, 77 bayt

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