숫자 를 올바르게 정사각형 과 삼각형으로 구분 하는 방법을 알았으므로 이제 평행 사변 형법을 배우겠습니다. 숫자를 평행 사변형으로 만들려면 먼저 숫자의 자릿수와 같은 횟수만큼 숫자를 쌓아 평행 사변형으로 정렬하고 공백을 추가하여 평행 사변형으로 만듭니다. 따라서 123다음과 같이 형성됩니다.

   123
  123
 123

이제 우리는 각각의 수평 및 수직 숫자를 가지고 추가, 123+123+123+1+12+123+23+3어느 같 531의 평행 사변형이다123 .

당신의 작업 :

숫자를 입력 할 때 숫자의 평행 사변형을 반환하는 프로그램이나 함수를 작성하십시오.

입력:

음수가 아닌 정수 또는 문자열로 표시되는 음이 아닌 정수

산출:

정수의 평행 사변형입니다.

테스트 사례 :

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

채점 :

이것은 code-golf 이며 바이트 단위의 최저 점수입니다!

MATL , 12 바이트

tnEXyPY+c!Us

입력은 문자열입니다. 온라인으로 사용해보십시오!

설명

'123'예를 들어 입력 을 고려하십시오 .

이 코드는 입력 ( t)을 복제하고 Xy입력 길이 ( 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

그런 다음 거꾸로 뒤집습니다 ( 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

숫자의 ASCII 코드로 해석되는 입력 문자열은 숫자 행 벡터와 같습니다.

49 50 51

Y+위의 벡터와 행렬의 풀 사이즈 2 차원 컨볼 루션 ( )

 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

이 숫자를 ASCII 코드 ( c) 로 다시 해석 하면 다음 문자 행렬이 제공되고 문자 0은 공백으로 표시됩니다.

     123
    123 
   123  
  123   
 123    
123

조옮김 ( !)은 이것을

     1
    12
   123
  123 
 123  
123   
23    
3     

각 행을 숫자 ( U) 로 해석 하면 숫자 열 벡터가 제공됩니다.

  1
 12
123
123
123
123
 23
  3

그것을 합하면 s최종 결과가 531됩니다.

망막 , 22 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명 : 첫 번째 단계는 각 숫자에서 입력 번호를 분할하고 모든 독점 접 두부 및 포함 접미 부를 포함하여 수직 숫자를 제공하고 각 숫자에 대해 반복 된 원래 입력 숫자와 수평 숫자를 제공합니다. 나머지 단계는 단순히 결과 숫자를 합산합니다.

05AB1E ,  12 11  8 바이트

_{I 'm 확실히 이 알고 있습니다 더 golfed 수 - 팁 환영합니다!}

Outgolfer Erik에게 -1 바이트 감사 (랩핑을 피하고 연결을 사용)-
그리고
Adnan 덕분에 -3 바이트 더하기 (더하기를 벡터화하고 끝에 입력을 빼서 길이 -1로 곱셈을 피하십시오)

.s¹η++Oα

온라인으로 사용해보십시오!

어떻게?

.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

하스켈 , 90 78 76 71 64 63 59 57 바이트

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

온라인으로 사용해보십시오!

껍질 , 13 12 바이트

ṁit§+SRL§+ḣṫ

온라인으로 사용해보십시오!

설명

              -- 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 바이트

𝐱S𝐗𝔻𝔻𝐬𝕤

조심하십시오. 뱀이 들어 있습니다 :S𝐬𝕤

온라인으로 사용해보십시오!

파이썬 3 , 85 70 바이트

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의 경우 :

정수로 캐스트하기 전에 문자열 색인화를 색인 (r) = 1,2,3,4로 사용하여 입력 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345의 슬라이스를 요약합니다. , 12345 * 2에 추가

특별히 감사함:

-14 바이트 @ 조나단 앨런

-1 바이트 @ovs

온라인으로 사용해보십시오!

Japt , 15 11 바이트

@Shaggy 덕분에 -4 바이트.

¬£iYç
cUz)x

입력을 문자열로받습니다.

온라인으로 사용해보십시오!

설명

£

입력 배열을 숫자 ( ¬) 로 나누고 £다음 함수 ( )로 매핑합니다 ( 여기서 Y는 색인 임).
["1", "2", "3"]

iYç

시작 부분에 Y공백 ( ç)이 삽입 된 ( i) 입력 값 (암시 적) 에 할당되어 U있습니다.
["123", " 123", " 123"]

cUz1)x

그 자체를 90 ° 오른쪽으로 회전시켜 연결하십시오 ( 1시간). 그런 다음 합계 ( x).
["123", " 123", " 123", " 1", " 12", "123", "23 ", "1 "]-> 531.

apt , 31 18 바이트

@ETHproductions 덕분에 -13 바이트

이 방법은 Japt를 사용하여 제대로 작동하지 않습니다. 저스틴의 솔루션 이 훨씬 좋습니다.

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

설명:

[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

온라인으로 사용해보십시오!

루비 , 61 55 + 1 = 56 바이트

사용 -n플래그를 . STDIN에서 입력.

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

온라인으로 사용해보십시오!

자바 스크립트, 77 74 바이트

Value Ink 덕분에 3 바이트 절약

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 바이트

내 현재 접두사 접근 방식 (추가로 골프를 치기 바랍니다).

+*tlQsQssM+_M.__Q._

스위트를 테스트 하거나 동일한 바이트 수를 가진 대체 방법을 시도 하십시오 .

설명

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

개념을 더 잘 이해하기 위해 예를 들어 보겠습니다 "123".

• 먼저 입력의 접두사를 얻습니다. 그것들은 ['1', '12', '123']입니다.

• 그런 다음 반전 된 입력의 접두사를 ['3', '32', '321']얻습니다 ['3', '23', '123']. 즉 , 각각을 반대로하여 얻을 수 있습니다.

• 두 목록을 연결하고 각 요소를 정수로 변환하여를 얻습니다 [3, 23, 123, 1, 12, 123].

• 목록을 합하면 결과는 285입니다.

• 곱은 P입력 길이에 1을 2곱한 값 ( )을 곱한 값 2 * 123 = 246입니다.

• 결국 우리는 두 가지 결과를 요약합니다. 285 + 246따라서 우리 531는 올바른 결과입니다.

Pyth , 20 바이트

+*hlQsQsm+s>Qds<QdtU

테스트 스위트.

설명

추가 골프 후 올 설명. 나는 이것을 지금까지 더 이상 골프에 성공하지 못했습니다 (나는 아이디어가 있습니다).

+*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 바이트

해결책:

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

예 :

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

설명:

{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

젤리 , 18 바이트

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

온라인으로 사용해보십시오!

스위프트 3 , 213 바이트

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

속도가 느리고 시간이 초과되어 온라인으로 테스트 할 수 없습니다. 테스트하려면 Swift Playgrounds에서 사용해 볼 수 있습니다.

샘플 런

입력:

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

산출:

531
417
10288049

젤리 , 12 바이트

LḶṚ⁶ẋ;€µ;ZVS

온라인으로 사용해보십시오!

입력을 문자열로받습니다. "평행 사변형"을 문자 행렬로 만든 다음 각 행과 열을 평가하여 숫자를 합산합니다.

설명

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 바이트 (78 + -lm컴파일러 플래그)

안녕하세요! 이것은 첫 번째 제출물이며 규칙을 어 기지 않기를 바랍니다.

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

온라인으로 사용해보십시오!

경고없이 언 골프 :

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

자바 8, 147 137 126 116 114 바이트

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 덕분에 -13 바이트 (137 → 126 및 116 → 114) .

설명:

여기에서 시도하십시오.

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 바이트

c ()를 사용하지 않고 -6 바이트

@Giuseppe 덕분에 -59 바이트

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}

온라인으로 사용해보십시오!

입력을 문자열로받습니다.

나는 주로 R의 강점을 활용하여 개선이 이루어질 것이라고 확신합니다 ...하지만 기본적으로 문자열 조작이라는 도전에서 어떻게 보려고 고심하고 있습니다.

편집 : 나는 나쁜 생각을 반복하지 않기 때문에 훨씬 나아졌습니다!

펄 5 , 53 + 1 (-n) = 54 바이트

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

온라인으로 사용해보십시오!

수학, 77 바이트

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