Параллелограмм числа

18

Теперь, когда мы знаем, как правильно поставить квадрат и треугольник , мы научимся распараллеливать одно. Чтобы распараллелить число, мы сначала упорядочиваем его как параллелограмм, укладывая его поверх себя число раз, равное количеству имеющихся у него цифр, и добавляя пробелы, чтобы сделать его параллелограммом. Так 123бы сформировалось:

   123
  123
 123

Теперь мы берем каждое горизонтальное и вертикальное число и добавляем их 123+123+123+1+12+123+23+3, что равно 531, что является параллелограммом 123.

Твое задание:

Напишите программу или функцию, которая при задании числа в качестве входного сигнала возвращает параллелограмм числа.

Входные данные:

Неотрицательное целое число или неотрицательное целое число, представленное строкой.

Выход:

Параллелограмм целого числа.

Тестовые случаи:

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

Подсчет очков:

Это код-гольф , выигрывает самая низкая оценка в байтах!

code-golf  number 
— Грифон - Восстановить Монику
источник
— Грифон - Восстановите Монику
Почему отрицательный голос?
— Грифон - Восстановить Монику

Ответы:

9

MATL , 12 байт

tnEXyPY+c!Us

Ввод - это строка. Попробуйте онлайн!

объяснение

Рассмотрим ввод '123'в качестве примера.

Код дублирует input ( 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+) указанного вектора и матрицы дает

 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

Transposition ( !) превращает это в

     1
    12
   123
  123 
 123  
123   
23    
3

Интерпретация каждой строки как числа ( U) дает вектор числового столбца

  1
 12
123
123
123
123
 23
  3

и суммирование ( s) дает окончательный результат 531.

— Луис Мендо
источник
1
Я чувствую запах ... свертки
— Аднан
1
@ Adnan Что еще? :-D
— Луис Мендо
6

Сетчатка , 22 байта

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

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Пояснение: Первый этап разбивает входной номер на каждую цифру и включает все исключительные префиксы и включающие суффиксы, давая вертикальные числа, а также исходный номер ввода, повторяемый для каждой цифры, давая горизонтальные числа. Остальные этапы просто суммируют полученные числа.

— Нил
источник
6

05AB1E ,  12 11  8 байт

Я уверен, знал , что это может быть в гольфе дальше - советы приветствуются!

-1 байт благодаря Эрику Outgolfer (избегайте переносов, но используя конкатенацию),
а затем ...
-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
— Джонатан Аллан
источник
Вы можете использовать «для объединения суффиксов и префиксов:g<*¹.s¹η«O+
— Эрик Outgolfer
1
.s¹η++Oαдолжно работать на 8 байтов
— Аднан
Спасибо @EriktheOutgolfer две обертки показались мне странными!
— Джонатан Аллан
@ Аднан - это очень мило!
— Джонатан Аллан
@JonathanAllan "советы приветствуются!" не уверен, что получишь больше ...
— Эрик Аутгольфер
4

Шелуха , 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)
— H.PWiz
источник
4

Python 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:

Суммирует фрагменты ввода 1 + 2345 + 12345, 12 + 345 + 12345, 123 + 45 + 12345, 1234 + 5 + 12345, используя индексацию строки до index (r) = 1,2,3,4 перед приведением к целому числу и добавляет к 12345 * 2

Особая благодарность:

-14 байт @ Джонатан Аллен

-1 байт @ovs

Попробуйте онлайн!

— Коннер Джонстон
источник
TIO ссылается на неправильный код. (len(n)+1)может быть добавлено -~len(n)( ~xесть -1-x), и тогда это может сохранить другой байт с помощью -i(n)*~len(n). Тогда вы можете сделать все это анонимной функцией: lambda n,i=int:sum(i(n[:r])+i(n[r:])for r in range(1,len(n)))-i(n)*~len(n)(74 байта)
— Джонатан Аллан
Еще лучше сделать эту функцию рекурсивной для 71 байта:f=lambda n,r=1,i=int:n[r:]and i(n[r:])+i(n[:r])+f(n,r+1)or-i(n)*~len(n)
— Джонатан Аллан
1
— OVS
Я исправил вашу тио ссылку.
— Мистер Кскодер
3

Japt , 15 11 байт

-4 байта благодаря @Shaggy. 

¬£iYç
cUz)x

Принимает ввод как строки.

Попробуйте онлайн!

объяснение

£

Разбить входной массив на digits ( ¬) и отобразить с помощью ( £) следующую функцию, где 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.

— Джастин Маринер
источник
Точно, как я пытался это сделать, но я по какой-то причине не смог туда добраться - прекрасно сделано :) Вот 13-байтовая версия.
— Лохматый
— Shaggy
@ Shaggy Отлично, я знал, что должен быть более короткий способ, чтобы добавить пробелы к каждой строке. Благодарность!
— Джастин Маринер
3

Джапт , 31 18 байт

-13 байт благодаря @ETHproductions

Этот подход не работает хорошо с использованием 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

Попробуйте онлайн!

— Оливер
источник
3
Вот и все, я добавляю ярлык для Ul : P
— ETHproductions
Хм ... вам не нужно ни одного из Us в функциях, а средний элемент в массиве может быть сжат, до Uå+ xкоторого, я думаю, вы получите 23 байта.
— ETHproductions
@ETHproductions Спасибо! Я получил его еще один байт, переставив элементы массива.
— Оливер
Вы можете изменить mx xна xx? :-)
— ETHproductions
@ETHproductions Я уверен, что могу, спасибо еще раз :)
— Оливер
2

Руби , 61 55 + 1 = 56 байт

Использует -nфлаг. Ввод из STDIN.

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

Попробуйте онлайн!

— Значение чернил
источник
Для ввода 102033ваша программа печатает 728714при правильном значении 729702.
NOOOO! КУРС ВАС ОКТАЛЬНЫЕ ПРЕДСТАВИТЕЛЬСТВА! (исправление ошибок, 02033была проблема)
— Value Ink
Я предположил, что восьмеричные числа являются проблемой, но я не был уверен (кстати, я не знаю, рубин). Спасибо за разъяснения :)
@ThePirateBay не проблема; Я уже работал над более коротким, альтернативным решением, которое требовало ввода строки, и даже с необходимыми исправлениями я фактически все
— Value Ink
2

JavaScript, 77 74 байта

Сохранено 3 байта благодаря 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'));
Развернуть фрагмент

1

Pyth , 20 19 байтов

Мой нынешний подход к префиксам (будем надеяться, дальше в гольф).

+*tlQsQssM+_M.__Q._

Test Suite или попробуйте альтернативный подход с тем же количеством байтов .

объяснение

+*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.
— Мистер Xcoder
источник
1

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
— streetster
источник
1

Swift 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, если вы хотите проверить это.

Пробный прогон

Входные данные:

е (п: "123")
е (п: "101")
е (п: "1234567")

Выход:

531
417
10288049
— Мистер Xcoder
источник
1

Желе , 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
— миль
источник
1

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;
}
— scottinet
источник
Выглядит актуально для меня :)
— Okx
Хм, -lmдля математических функций требуется только для некоторых сред выполнения C, например glibc. Компиляция, например, с MinGW (используя Microsoft msvcrt.dll), не понадобится. Так не уверен, что это необходимо добавить сюда? В любом случае, если вы добавите его, то получится 3 байта;)
— Феликс Пальмен,
К сожалению, -lmнеобходим для pow()функции с gcc. Я пытался работать без него, но не смог найти решение, используя менее 6 байт (pow + флаг компилятора). Я не смог найти правила о том, как включить флаги в bytecount, и я знаю, что я сделал неверное предположение о том, что -персонаж не учитывается. Я добавляю +1 байт прямо сейчас.
— scottinet
-lmне требуется, gccно факт, что glibcне включает математические функции в основную библиотеку. msvcrt.dllделает, поэтому компиляция на windows с gccработами без -lm. Это придирки, и я не совсем уверен, что на самом деле должны сказать правила об этом.
— Феликс Пальмен,
Спасибо за внимание :) Я не могу попробовать ваше предложение, и, к сожалению, tio тоже не предлагает такой возможности
— scottinet
1

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

-13 байтов (137 → 126 и 116 → 114) благодаря @ OlivierGrégoire .

Объяснение:

Попробуй это здесь.

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
— Кевин Круйссен
источник
1
114 байт: n->{Integer l=(n+"").length(),s=n*l,i=0;for(;++i<l*2;)s+=l.valueOf((n+"").substring(l<i?i-l:0,i<l?i:l));return s;}. Это скользящее окно с min-max, чтобы уменьшить количество звонков для дорогихnew Integer(....substring(...))
— Оливье Грегуар
1
@ OlivierGrégoire Спасибо, и даже может укоротить еще немного изменив Math.max(0,i-l)к 0>i-l?0:i-lи Math.min(i,l)к i>l?l:i. Изменяя это сейчас. Ах, я вижу, что вы отредактировали свой комментарий после того, как я скопировал 126-байтовый ответ. ;)
— Кевин Круйссен
Да, извините за редактирование, но я не проверял это;)
— Оливье Грегуар
1

R , 168 162 103 байт

-6 байт, не используя c ()

-59 байт благодаря @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}

Попробуйте онлайн!

Принимает ввод в виде строки.

Я абсолютно уверен, что необходимо внести улучшения, в первую очередь, используя все сильные стороны R ... но в задаче, которая в основном заключается в манипуляциях со строками, я изо всех сил пытаюсь понять, как это сделать.

Изменить: гораздо лучше, теперь, когда я не повторяю плохую идею!

— CriminallyVulgar
источник
1
— Джузеппе
@ Джузеппе Ах, спасибо! Это было много потраченного впустую пространства, когда я все еще использовал целочисленный ввод. Мне нравится strtoi (substr ()), а трюк (a | b) намного умнее, чем я. Спасибо за улучшения! Это почти другой ответ на данный момент ...
— CriminallyVulgar
Это происходит, когда вы добавляете другой подход! Я не мог понять циклы сам, но я думаю, что вы могли бы построить индексы для substrявного вместо цикла, что сэкономило бы несколько байтов.
— Джузеппе
0

Mathematica, 77 байтов

(s=IntegerDigits@#;t=Length@s;Tr[FromDigits/@Table[s~Take~i,{i,-t,t}]]+t#-#)&
— J42161217
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.