Выведите Волшебную Трапецию 8

41

Ваша задача - вывести Волшебную Трапецию 8:

        1 × 8 + 1 = 9
       12 × 8 + 2 = 98
      123 × 8 + 3 = 987
     1234 × 8 + 4 = 9876
    12345 × 8 + 5 = 98765
   123456 × 8 + 6 = 987654
  1234567 × 8 + 7 = 9876543
 12345678 × 8 + 8 = 98765432
123456789 × 8 + 9 = 987654321
  • Вывод на выбранном вами языке в наименьшем количестве байтов.
  • Запишите количество пробелов в начале каждой строки, чтобы сохранить форму трапеции.
  • Промежуточные пробелы разрешены.
  • Вы можете использовать ×или букву х - что вы предпочитаете.
code-golf  kolmogorov-complexity 
— rybo111
источник
1
Связанный. (немного ...)
— Мартин Эндер
Средние пробелы требуются, да?
— Value Ink
@ KevinLau-notKenny это так, но вы всегда можете опубликовать альтернативу, если это важно.
— rybo111
Это 6 байтов, соответствующих 6 пробелам в середине, так что нет, я не думаю, что это достаточно существенно.
— Value Ink

Ответы:

15

Python 2, 59 байт

a=i=1
exec"print'%9d x 8 +'%a,i,'=',a*8+i;i+=1;a=a*10+i;"*9

Числа aи iуравнение a * 8 + iгенерируются арифметически. Каждая строка iувеличивается, и aк ней добавляется следующая цифра a=a*10+i. Например, если a=12345, i=5, тогда iстановится 6, значит, новое aесть то, 12345*10 + 6что есть 123456.

Сохранение их в виде чисел, а не строк позволяет нам вычислить RHS, как указано в уравнении a*8+i, которое короче, чем обращение строк.

— XNOR
источник
+1 за то, что это
— видно
7

V , 37 байт

i¸ 1 X 8 + 1 = 98ñYp|Eylp^Xf+$ylp

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

Это содержит непечатаемый, поэтому вот hexdump:

00000000: 69c2 b820 3120 5820 3820 2b20 3120 3d20  i.. 1 X 8 + 1 = 
00000010: 391b 38c3 b159 707c 4579 6c70 015e 5866  9.8..Yp|Eylp.^Xf
00000020: 2b01 2479 6c70 18                        +.$ylp.
— DJMcMayhem
источник
5

05AB1E , 32 31 30 28 байт

Код:

TG9N-ð×NLJðN"x8+ÿ="€ðJžmN£J,

Использует кодировку CP-1252 . Попробуйте онлайн! ,

— Аднан
источник
.cздесь нельзя использовать?
— Волшебная урна осьминога
@carusocomputing Это так, но это ставит перед собой задачу.
— Аднан
Аааа ... не видел отметку времени.
— Волшебная Осьминог Урна
5

PHP, 105 89 60 57 байт

моя первая попытка игры в гольф здесь (спасибо manatwork & user55641)

for(;$i++<9;)printf("%9s x 8 + $i = %s
",$s.=$i,$s*8+$i);

59

for(;$i++<9;)printf("%9s x 8 + $i = %s
",$s.=$i,$t.=10-$i);

89 (моя собственная попытка)

for(;@++$i<=9;){printf("%9s x 8 + %s = %s\n",join(range(1,$i)),$i,join(range(9,10-$i)));}

105 (первый)

for($j='123456789';@$j[$i++];){printf("%9s x 8 + %s = %s\n",substr($j,0,$i),$i,strrev(substr($j,-$i)));}
— крипто-
источник
1
Нет необходимости в скобках вокруг одного утверждения. Один только $ i лучше интерполировать непосредственно в строке без спецификатора формата.
— Манатворк
1
Вы можете сбросить еще 23 байта с помощью нескольких хитростей: изменение @ ++ $ i <= 9 на $ i ++ <9 экономит 2 байта. Вам не нужно отключать уведомления, поскольку они не останавливают выполнение, и в соответствии со стандартными правилами PPCG вы можете игнорировать stderr, если хотите. Изменение символа \ n на символ новой строки сохраняет байт. Изменение битов соединения (диапазона (...)) на $ s. = $ I и $ t. = 10- $ i позволяет сэкономить 15 байтов. Это работает, потому что назначения возвращают назначенное значение и в значительной степени самый ценный прием, который я нашел для игры в гольф php. Последние 5 байтов детализированы manatwork выше
— user55641
1
Вы можете сбросить еще 2 байта, заменив $t.=10-$iна $s*8+$i. tio.run/##K8go@G9jXwAk0/…
— 640KB
1
Это 59 байтов. И $s*8+$iвместо того, чтобы $t.=10-$iсохранить еще два.
— Титус
5

Pyth, 32 байта

VS9ss[*dK-9NSN" x 8 + "N" = "r9K

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

VS9ss[*dK-9NSN" x 8 + "N" = "r9K
VS9                                  # For N in 1..9
   s                                 # Join without delimiter
    s[                               # Reduce the array on + (flattens)
      *dK-9N                         # - Space, repeated K=(9-N) times
            SN                       # - The string sequence 1..N
              " x 8 + "              # - This string literal
                       N             # - N itself
                        " = "        # - This string literal
                             r9K     # - The string sequence 9..K

Спасибо @FryAmTheEggman за сохранение 2 байта. Спасибо @KennyLau за сохранение 3 байта.

— Вен
источник
sне соединяется с пробелом - он соединяется без разделителя.
— Исаак
@isaacg Хах, и теперь я думаю, что смогу сохранить байт, объединившись с пробелом
— Ven
Количество байтов будет таким же .
— Утренняя монахиня
4

CJam, 39 38 36 байт

Спасибо оптимизатору за сохранение 2 байта.

9{)_,:)9Se[" x 8 + "@S'=S9_,fm4$<N}/

Проверьте это здесь.

Тот же счетчик байтов:

9{)_,:)9Se[]"x8+"+:\'=9_,f-Y$<]S*n}/

Для этого требуется последняя версия, доступная на Попробуй онлайн!

— Мартин Эндер
источник
9
Тогда @Optimizer соответствовал его имени!
— rybo111
4

Python 2, 87 84 78 75 байт

s="123456789"
n=1
exec'print"%9s"%s[:n],"x 8 + %s ="%n,s[::-1][:n];n+=1;'*9

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

Предыдущая версия использует магию строк.

R=range(1,10)
for n in R:print" "*(9-n)+`R`[1:n*3:3]+" x 8 + %d = "%n+`R`[-2:27-3*n:-3]

Приведение range(1,10)к строке дает [1, 2, 3, 4, 5, 6, 7, 8, 9], и это хорошо, так как каждое число - только одна цифра. Таким образом, получить строку 123456789из этого просто с `range(1,10)`[1::3]. Обратный диапазон есть `range(1,10)`[-2::-3]. Затем, чтобы получить только то, что мне нужно для каждой итерации, я обрезаю ее либо в точке 3*n, либо в точке 3*(9-n)( 27-3*n) для обратных цифр.

— mbomb007
источник
Вы можете сделать for n in range(1,10):print"%9s"%s[:n]+" x 8 + %s = "%n+s[::-1][:n]за 80 байтов.
— TheBikingViking
s="123456789";n=1;exec'print"%9s"%s[:n],"x 8 + %s ="%n,s[::-1][:n];n+=1;'*9экономит еще три! До 75.
— Линн
Здорово, спасибо за помощь! Жаль, что мне пришлось дважды нарезать ломтик ...
— mbomb007
4

Рубин, 77 73 65 60 байт

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

Основные обновления от @manatwork

Еще один капитальный ремонт от @xsot

a=i=0;9.times{puts"%9d x 8 + %d = %d"%[a=a*10+i+=1,i,a*8+i]}
— Значение чернил
источник
Кажется, короче со строкой формата: puts'%9d x 8 + %d = %d'%[k=[*1..i]*'',i,k.to_i*8+i].
— Манатворк
(1..9).map→1.upto(9)
— manatwork
Ах, я не знал, %9dчто такое опция форматирования для добавления целых чисел
— Value Ink
60:a=i=0;9.times{puts"%9d x 8 + %d = %d"%[a=a*10+i+=1,i,a*8+i]}
— xsot
@ xsot это здорово! Не думал вычислить начальное число таким образом.
— Value Ink
4

Java 10, 151 133 130 129 126 110 байт

v->{String p="\n",r="";for(int n=123456789,i=9;i>0;n/=10,p+=" ")r=p+n+" x 8 + "+i+" = "+(n*8+i--)+r;return r;}

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

Объяснение:

v->{                   // Method with empty unused parameter and String return-type
  String p="\n",       //  Prefix-String, starting at a newline
         r="";         //  Result-String, starting empty
  for(int n=123456789, //  Multiply-number, starting at 123456789
      i=9;i>0          //  Loop `i` in the range [9, 0):
      ;                //    After every iteration:
       n/=10,          //     Remove the last digit from the integer
       p+=" ")         //     Append a space after the prefix
    r=...+r;           //   Prepend the following to the result-String:
      p                //    The prefix-String
      +n               //    Followed by the integer
      +" x 8 + "       //    Followed by the literal String " x 8 + "
      +i               //    Followed by the loop-index `i`
      +" = "           //    Followed by the literal String " = "
      +(n*8+i--)       //    Followed by the result of that equation
  return r;}           //  Return the result-String
— Кевин Круйссен
источник
1
Я думаю, что вы могли бы сохранить байты, используя xвместо знака умножения.
— wizzwizz4
1
Вы можете сохранить несколько байт инициализацией sдля "\n"и удаления "\n"+из forпетли
— cliffroot
@ wizzwizz4 Спасибо. Должен был знать, что ×это 2 байта вместо 1 как x...
— Кевин Круйссен
Разве вы не добавляете sрезультат к каждой итерации?
— Cliffroot
Я знаю, что это старый, но вы не можете сделать return oвместо System.out.print(o)? Также вы можете перейти на Java 10 и сохранить с помощью varи лямбды
— Embodiment of Ignorance
3

C #, 113 байт

void f(){for(int n=1,i=1;i<10;n=10*n+ ++i)Console.WriteLine(new string(' ',9-i)+n+" x "+"8 + "+i+" = "+(n*8+i));}

Если у вас есть возможность улучшить это решение, не стесняйтесь поделиться.

— ScifiDeath
источник
Вы можете сохранить 1 байт, удалив пробел: ;n=10*n+ ++iв цикле for можно изменить на ;n=++i+10*n. Также +" x "+"8 + "+можно изменить на +" x 8 + "+. сохранить еще 3 байта.
— Кевин Круйссен
void f () {for (int n = 1, i = 1; i <10; n = ++ i + 10 * n) Console.WriteLine ($ "{новая строка ('', 9-i)} {n } x 8 + {i} = {(n * 8 + i)} ");} ------------ спас вам байт!
— downrep_nation
3

Пакет, 117 байт

@echo off
set a=         12345678987654321
for /l %%i in (1,1,9)do call echo %%a:~%%i,9%% x 8 + %%i = %%a:~17,%%i%%

Да, это 16% знаков на одной строке; это партия для вас!

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

Haskell, 92 байта

s=(show=<<)
[1..9]>>= \x->([x..8]>>" ")++s[1..x]++" x 8 + "++s[x]++" = "++s[9,8..10-x]++"\n"

Как это работает:

s=(show=<<)                   -- helper function that turns a list of numbers into
                              -- a string without delimiters, e.g. [1,2] -> "12"

[1..9]>>=                     -- for each number 1 to 9
     ([x..8]>>" ")            -- take length of [x..8] copies of a space
     s[1..x]                  -- the digits from 1 to x
     " x 8 + "                -- a string literal
     s[x]                     -- the digit of x
     " = "                    -- another string literal
     s[9,8..10-x]             -- the digits from 9 down to 10-x
     "\n"                     -- an a newline
— Ними
источник
2

Пайк, 30 29 байт

9Fd*~utj+9<\x8\+9i-\=ji>_dJ)X

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

9F                         )  -  for i in range(9):
  d*                          -       " " * i
        +                     -      ^ + V
       j                      -       j = V
    ~ut                       -        "123456789"
         9<                   -     ^[:9]
           \x8\+9i-\=         -    [^, "x", 8, "+", (9-i), "=", V]
                        _     -     reversed(V)
                     ji>      -      j[i:]
                         dJ   -   " ".join(^)
                            X - print(reversed(^))
— синий
источник
2

PowerShell v2 +, 85 64 58 57 52 байта

8..0|%{" "*$_+-join(1..++$i+" x 8 + $i = "+9..++$_)}

Циклы от 8 до 0 8..0|%{...}через оператора диапазона. На каждой итерации мы выводим конкатенацию строк, состоящую из (соответствующего числа пробелов " "*$_), плюс -joinстроку ed (диапазон от 1предварительно увеличенного вспомогательного числа ++$i, плюс средний бит " x 8 + $i = "плюс окончательный диапазон от 9текущего номера $_до -incremented).

Здесь есть одна большая хитрость: мы используем «левое предпочтение» для приведения типов, что позволяет нам «добавлять» массивы вместе в -joinскобках, то есть мы используем только один -joinоператор.

пример

PS C:\Tools\Scripts\golfing> .\magical-8-trapezium.ps1
        1 x 8 + 1 = 9
       12 x 8 + 2 = 98
      123 x 8 + 3 = 987
     1234 x 8 + 4 = 9876
    12345 x 8 + 5 = 98765
   123456 x 8 + 6 = 987654
  1234567 x 8 + 7 = 9876543
 12345678 x 8 + 8 = 98765432
123456789 x 8 + 9 = 987654321
— AdmBorkBork
источник
4
%{С твоими глазами все в порядке?
— gcampbell
@gcampbell Если бы у тебя были такие глаза, ты бы тоже нахмурился.
— AdmBorkBork
Зависит от того, как ваш шрифт отображает проценты.
— gcampbell
2

J 51 байт

(|."1|.\p),.' x 8 + ',"1]p,.' = ',"1]\|.p=:u:49+i.9

Создает строку, 123456789а затем использует префиксы и суффиксы для создания выходных данных.

использование

   (|."1|.\p),.' x 8 + ',"1]p,.' = ',"1]\|.p=:u:49+i.9
        1 x 8 + 1 = 9        
       12 x 8 + 2 = 98       
      123 x 8 + 3 = 987      
     1234 x 8 + 4 = 9876     
    12345 x 8 + 5 = 98765    
   123456 x 8 + 6 = 987654   
  1234567 x 8 + 7 = 9876543  
 12345678 x 8 + 8 = 98765432 
123456789 x 8 + 9 = 987654321
— миль
источник
2

JavaScript ES6 (88)

Используя в своих интересах новый repeatметод, кавычки и шаблонирование ...

i=10;for(y="";--i;)console.log(`${" ".repeat(i)+(y+=(x=10-i))} x 8 + ${x} = ${y*8+x}\n`)
— Уолли Уэст
источник
Хорошая работа, братан, вы должны рассмотреть возможность удалить некоторое пространство и использовать alertвместо него console.log, это может сэкономить несколько байтов!
— Чау Гианг
Учитывая, что я ответил на это незадолго до полуночи, я полагаю, что я был почти наполовину спящим ... Я скоро опубликую обновление. LOL
— WallyWest
2

R 107 103 байт

a=1;for(i in 2:10){cat(rep("",11-i),paste(a,"x",8,"+",(i-1),"=",strtoi(a)*8+(i-1)),"\n");a=paste0(a,i)}

Ungolfed:

a=1

for(i in 2:10)
    cat(rep("",11-i),paste(a,"x",8,"+",(i-1),"=",strtoi(a)*8+(i-1)),"\n")
    a=paste0(a,i)

Результат:

        1 x 8 + 1 = 9 
       12 x 8 + 2 = 98 
      123 x 8 + 3 = 987 
     1234 x 8 + 4 = 9876 
    12345 x 8 + 5 = 98765 
   123456 x 8 + 6 = 987654   
  1234567 x 8 + 7 = 9876543 
 12345678 x 8 + 8 = 98765432 
123456789 x 8 + 9 = 987654321
— Фредерик
источник
— Джузеппе
2

APL (Dyalog Unicode) , 61 52 39 байт SBCS

↑(⍳9)((¯9↑↑),' x 8 +',⊣,'= ',↑∘⌽)¨⊂1↓⎕D

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

-9 байт, используя 10⊥трюк для разбора числа вместо уменьшения. Спасибо @ Adám за -13!

Объяснение:

↑    ((¯9↑↑),' x 8 +',⊣,'= ',↑∘⌽)¨⊂1↓⎕D
                                     ⎕D  ⍝ Numbers from 0 to 9
                                   1↓    ⍝ Drop the 0
 (⍳9)(                          )¨⊂      ⍝ Do 9 times, N=current
                             ↑∘⌽         ⍝ Reverse the string (9..1) and cut off N elements
                      ⊣                  ⍝ N itself
      (   ↑)                             ⍝ Drop N elements off the 1..9 string...
      (¯9↑ )                             ⍝ ...then pad it back with spaces
            ,' x 8 +', ,'= ',            ⍝ Join with a few constant strings
↑                                        ⍝ Format
— Вен
источник
1

JavaScript (ES6), 99 байт

_=>[...Array(9)].map((n,i)=>`${n="        123456789".substr(i,9)} x 8 + ${++i} = ${n*8+i}`).join`\n`
_=>".........".replace(/./g,(n,i)=>`${n="        123456789".substr(i,9)} x 8 + ${++i) = ${n*8+i}\n`)

Где \nпредставляет буквальный символ новой строки. Вторая версия выводит завершающий перевод строки. Я придумал формулу для чисел, ('1'.repeat(9-i)+0+i)/9но заполнение было легче сделать таким образом.

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

Javascript (с использованием внешней библиотеки) (143 байта)

n=>_.Range(1,9).WriteLine(v=>_.Range(0,10-v).Write("",x=>" ")+_.Range(1,v).Write("")+" x 8 + " + v + " = "+_.Range(10-v,v).Reverse().Write(""))

Ссылка на lib: https://github.com/mvegh1/Enumerable/

Объяснение кода: создайте диапазон от 1 до 9, и для каждого значения напишите строку, соответствующую сложному предикату. Предикату передается текущее целочисленное значение и создается диапазон, охватывающий элементы 10-currentValue, для создания такого количества пробелов. Эти пробелы объединяются с частью формулы в строке, а затем соединяются с таилендом диапазона, соответствующим количеству элементов в качестве внешнего интерфейса, в обратном порядке.

Примечание. В изображении первая строка отключена на один пробел, поскольку консоль добавила кавычку, поскольку возвращаемое значение является строкой. Фактическое значение отформатировано правильно

введите описание изображения здесь

— applejacks01
источник
1

05AB1E , 24 байта

9Lε©LJ'x8'+®'=T®L-Jðý}.c

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

Использует более новую версию, чем задача, которая теперь разрешена.

— Эрик Outgolfer
источник
Это не так много, но в еще более новой версии 05AB1E вы можете удалить ©и изменить , ®чтобы yсохранить байт.
— Кевин Круйссен
@KevinCruijssen Эх, я обычно не "обновляю" старые ответы, как это. Кроме того, «новая версия» - это совершенно другой язык (разные реализации).
— Эрик Outgolfer
1

VBA (Excel), 51 байт

Использование немедленного окна

For z=1To 9:a=a &z:?Spc(9-z)a" x 8 +"z"="a*8+z:Next
— remoel
источник
0

к (77 байт)

Возможно, может быть сокращено немного больше

-1@'((|t)#\:" "),'(t#\:n),'" x 8 + ",/:n,'" = ",/:(t:"I"$'n)#\:|n:"123456789";

Пример:

k)-1@'((|t)#\:" "),'(t#\:n),'" x 8 + ",/:n,'" = ",/:(t:"I"$'n)#\:|n:"123456789";
         1 x 8 + 1 = 9
        12 x 8 + 2 = 98
       123 x 8 + 3 = 987
      1234 x 8 + 4 = 9876
     12345 x 8 + 5 = 98765
    123456 x 8 + 6 = 987654
   1234567 x 8 + 7 = 9876543
  12345678 x 8 + 8 = 98765432
 123456789 x 8 + 9 = 987654321
— skeevey
источник
0

golflua, 56 знаков

p=""~@i=1,9p=p..i; w(S.q("%9s x 8 + %d = "..p*8+i,p,i))$

Образец прогона:

bash-4.3$ golflua -e 'p=""~@i=1,9p=p..i; w(S.q("%9s x 8 + %d = "..p*8+i,p,i))$'
        1 x 8 + 1 = 9
       12 x 8 + 2 = 98
      123 x 8 + 3 = 987
     1234 x 8 + 4 = 9876
    12345 x 8 + 5 = 98765
   123456 x 8 + 6 = 987654
  1234567 x 8 + 7 = 9876543
 12345678 x 8 + 8 = 98765432
123456789 x 8 + 9 = 987654321
— manatwork
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.