Квадрат текста

29

Соревнование

Учитывая строку, выведите текст в форме квадрата.

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

Вы также можете предположить, что никогда не будет новых строк.

пример

Input:
Hi, world

Output:
Hi,
 wo
rld

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

Input:
Hi, world! Hello

Output:
Hi, 
worl
d! H
ello

Input:
Lorem ipsum dolor sit amt

Output:
Lorem
 ipsu
m dol
or si
t amt

Input:
H

Output:
H

правила

  • Это код-гольф , поэтому выигрывает самый короткий ответ в байтах! Ответ Tiebreaker является наиболее одобренным.
  • Стандартные лазейки запрещены.
code-golf  string  grid 
— акролит
источник
Можем ли мы предположить, что на входе никогда не будет новых строк?
— MayorMonty
@MayorMonty да.
— Акролит
2
Можем ли мы вместо этого вывести массив строк?
— Утренняя монахиня
@LeakyNun нет 15 символов
— акролит
2
Можем ли мы печатать с новой строкой?
— Джузеппе

Ответы:

21

Vim, 59, 57 , 48 байт / нажатий клавиш

$:let @q=float2nr(sqrt(col('.')))."|li<C-v><cr><C-v><esc>@q"<cr>@q

Поскольку V имеет обратную совместимость, вы можете попробовать это онлайн!

Я случайно получил ответ на этот ответ, поэтому я снова просмотрел его. Мои навыки игры в vim-гольф значительно выросли за последние 7 месяцев, поэтому я увидел, что этот ответ был очень неудачным. Этот намного лучше.

— DJMcMayhem
источник
15

Brainfuck , 116 112 байтов

>>>>,[[<]<<+>>>[>],]<[<]<+<[>>+<[-<-<+>>]<<++[->>+<<]>]>[-]>>[<[->.[-]<[->+<]<+[->+<]>>]++++++++++.[-]<[->+<]>>]

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

Безопасный в ароматах BF, который не маскирует клетки 256, не поддерживает нулевые байты.

Удалите начальные стрелки вправо, если аромат поддерживает отрицательную память на 4 байта сохранено.

объяснение

Программа делится на 3 этапа:

Stage 1: >>>>,[[<]<<+>>>[>],]<[<]
Stage 2: <+<[>>+<[-<-<+>>]<<++[->>+<<]>]>[-]>>
Stage 3: [<[->.[-]<[->+<]<+[->+<]>>]++++++++++.[-]<[->+<]>>]

Этап 1

На этом этапе мы помещаем все символы на ленту, сохраняя при этом количество символов.

Это лента для ввода abcdefghiпосле этой ленты:

000 009 000 000 095 096 097 098 099 100 101 102 103
             ^

009 граф.

Для каждого символа мы перемещаем первый ноль слева [<]и затем добавляем один к счетчику <<+>>>, а затем перемещаемся к крайнему правому нулю[>] правому чтобы подготовиться к следующему символу.

Этап 2

Этот этап делает квадратный корень из длины, хранящейся во второй ячейке.

Это продолжает вычитать 1, 3, 5, 7, ... до тех пор, пока число не достигнет нуля, сохраняя при этом количество итераций.

Это работает, потому что квадратные числа могут быть выражены как 1 + 3 + 5 + ... .

Этап 3

Обозначим квадратный корень найденной выше длины как n .

Этот этап выводит nсимволы за раз, а затем выводит новую строку, пока лента не будет очищена.

— Дрянная Монахиня
источник
1
+1 не читал выглядит потрясающе, хотя
— Рохан Jhunjhunwala
10

05AB1E , 5 байтов

Dgtô«

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

D    duplicate a (implicit input)
g    length of a
t    square root of a
ô    push a split in pieces of b
«    join by newlines (implicit output)
— акролит
источник
1
Отличный ответ. Но как это работает? Не могли бы вы отредактировать, чтобы добавить объяснение?
— grooveplex
@grooveplex сделано.
— Акролит
Очень впечатляюще!
— Грифон - Восстановить Монику
3
Странно видеть старые ответы 05AB1E, где »сейчас переводы строк.
— Волшебная Урна Осьминога
8

MATL , 6 байтов

tnX^e!

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

объяснение

t     % Take input implicitly. Push another copy
n     % Get number of elements of the copy
X^    % Take square root
e     % Reshape the input into that number of rows, in column-major order
      % (which means: down, then across)
!     % Transpose so that text reads horizontally. Implicitly display
— Луис Мендо
источник
1
квадратный "тор"? : P
— Акролит
@daHugLenny :-D. Исправлено
— Луис Мендо
4
@daHugLenny Это обратный корень квадратный. ;-)
— WBT
7

Желе, 8 7 байт

sLƽ$j⁷

Сохраненный байт благодаря @ Деннис .

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

объяснение

sLƽ$j⁷  Input: string S
    $    Monadic chain
 L         Get the length of S
  ƽ       Take the integer square root of it, call it n
s        Split S into chunks of size n
     j⁷  Join using newline
— миль
источник
2
œsи sсделать то же самое здесь.
— Деннис
Почему ½не работает вместо ƽ?
— Луис Мендо
@ LuisMendo, потому что он возвращает число с плавающей запятой. Я исправлюсь, sи œsпоэтому они приведут к int.
— Деннис
Долгожданный патч @Dennis все еще ждет ...
— Эрик Outgolfer
7

JavaScript (ES7), 49 байт

s=>s.match(eval(`/.{${s.length**.5}}/g`)).join`
`

44 байта только в Firefox Nightly 43-46 ( **был введен некоторое время между Firefox Nightly 42 и 43 и gкак отдельный параметр был удален некоторое время между Firefox Nightly 46 и 47):

s=>s.match(`.{${s.length**.5}}`,`g`).join`
`
— Нил
источник
В первой версии , почему вам нужно +вs.length*+.5
— Downgoat
Я никогда не видел *+синтаксис раньше. Может ли кто-нибудь объяснить это?
— MayorMonty
Он, вероятно, имеет в виду **.
— Конор О'Брайен
@MayorMonty Да, это была опечатка извините.
— Нил
@ Downgoat Это была опечатка извините.
— Нил
7

J, 9 байт

$~,~@%:@#

Это монадический хук над строкой ввода:

$~ ,~@%:@#

Правильный зубец - это серия композиций:

,~ @ %: @ #

Слева - формирующий глагол, переключаемый таким образом, чтобы он работал в формате ловушки.

Вот некоторые промежуточные результаты:

   # 'hiya'
4
   %:@# 'hiya'
2
   ,~@%:@# 'hiya'
2 2

В словах:

   size =: #
   sqrt =: %:
   dup =: ,~
   on =: @
   shape =: $~
   block =: shape dup on sqrt on size
   block 'Hello, World! :)'
Hell
o, W
orld
! :)
— Конор О'Брайен
источник
2
Мне нравится тот факт, что он $~,~@напоминает какой-то смайлик, но @кажется странным для уха, но &подходит лучше, или$~,~&
— миль
1
И я полагаю, что они функционально эквивалентны. Ну, в основном. Один позволяет слышать лучше другого;)
— Конор О'Брайен
1
+1 за ваш счет будет n². Моя тоже :)
— Цифровая травма
@DigitalTrauma весело! +1 аналогично!
— Конор О'Брайен
1
$~2#%:@#равно 8. Левая часть вилки может быть константой.
— FrownyFrog
5

C, 64 байта

Позвоните f()со строкой в ​​квадрат.

m;f(char*s){for(m=sqrt(strlen(s));*s;s+=m)printf("%.*s\n",m,s);}

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

— owacoder
источник
1
Можете ли вы заставить его работать с неявным intаргументом вместо char*?
— Анатолий
Я так не думаю. Он должен быть разыменован, поэтому числовой тип не будет работать, и это не может быть, int*поскольку при добавлении он будет неправильно масштабироваться.
— owacoder
Предлагаю s+=write(puts(""),s,m));вместоs+=m)printf("%.*s\n",m,s);
— floorcat
5

Perl, 23 + 4 ( -pFфлаги) = 27 байт

-2 байта благодаря @DomHastings
-1 байтов благодаря @DomHastings

$==sqrt@F;s/.{$=}/$&
/g

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

Расширения : вычисляет квадратный корень (давайте назовем его Sдля объяснения) размера входных данных (это всегда будет целое число) ( @Fиспользуется в скалярном контексте, таким образом, возвращая его размер), затем добавьте новую строку после каждого блока Sсимволы.

— папа
источник
Хорошее использование $@;;) Вы можете сохранить байт, используя y///cвместо длины, и я думаю, что вы также можете использовать буквальную новую строку. Я пытался что-то сделать с настройкой $,и сопоставлением, но я думаю, что это намного короче!
— Дом Гастингс
1
@DomHastings Да, я думал, тебе понравится $@! Спасибо за то y///c, что склоняюсь к тому, что он существует.
— Дада
1
@DomHastings удалось сэкономить 1 байт, используя $=вместо $@, что позволяет не использовать -lфлаг.
— Дада
Хорошо идет! Хорошо использовать магические переменные и по подлинным причинам!
— Дом Гастингс
Эй, надеюсь, у тебя все хорошо! Это попало на домашнюю страницу, и я заметил еще одну оптимизацию для кода-pF
— Dom Hastings
4

зш, 36 байт

fold -`sed s/.$//<<<$[$#1**.5]`<<<$1

Принимает ввод в качестве аргумента командной строки, выводит в STDOUT.

                      $#1             get the length of the input string
                    $[   **.5]        take it to the .5 power (sqrt)
                 <<<                  and pass the result to
       sed s/.$//                     sed, which removes the last character
                                      this is because sqrt(9) is 3. instead of 3
     -`                       `       give the result as a command line flag to
fold                                  the fold util, which wraps at nth column
                               <<<$1  pass the input as input to fold
— Дверная ручка
источник
+1 за ваш счет будет n². Моя тоже :)
— Цифровая травма
4

05AB1E , 8 6 байт

Спасибо @quartata за сообщение о функции квадратного корня

Dgtô¶ý

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

объяснение

D     Implicit input. Duplicate
g     Number of elements
t     Square root
ô     Split into chunks of that length
¶     Push newline character
ý     Join list by newlines. Implicit display
— Луис Мендо
источник
Очень хорошо! Кроме того, «это сокращение от присоединения к новым строкам :).
— Аднан
1
@ Adnan Спасибо! Теперь я перехитрил себя :-D
— Луис Мендо
Я откатился на свою 6-байтовую версию, потому что был предыдущий ответ с«
— Луис Мендо
1
О, это очень плохо :(
— Аднан
Кто-нибудь еще чувствует, что эти языки, специально созданные для Code Golf, как бы портят привлекательность всего этого?
— Рене Рот
4

Python, 94 75 71 65 63 байта

import re;lambda r:"\n".join(re.findall("."*int(len(r)**.5),r))

Старая версия:

lambda r:"\n".join(map("".join,zip(*[iter(r)]*int(len(r)**.5))))
— акролит
источник
Обратите внимание, что вы можете использовать input() по умолчанию для получения ввода в кавычках, если вы не хотите специально удалить эту опцию.
— xnor
@xnor Ого, несколько дней назад мне было интересно, смогу ли я использовать кавычки при вводе ...
— acrolith
Не будет ли короче использовать лямбду?
— Утренняя монахиня
@LeakyNun правда ...
— акролит
3

Dyalog APL, 10 байт

⊢⍴⍨2⍴.5*⍨≢

Объяснение:

         ≢   length of the argument   
     .5*⍨    square root 
   2⍴        reshape that to a length-2 vector
⊢⍴⍨          reshape the input by that vector

тесты:

      (⊢⍴⍨2⍴.5*⍨≢)'Hi, world'
Hi,
 wo
rld
      (⊢⍴⍨2⍴.5*⍨≢)'Hi, world! Hello'
Hi, 
worl
d! H
ello
      (⊢⍴⍨2⍴.5*⍨≢)'Lorem ipsum dolor sit amt'
Lorem
 ipsu
m dol
or si
t amt
      (⊢⍴⍨2⍴.5*⍨≢) 'H'
H
— Мэринус
источник
3

Чеддер, 27 байтов (не конкурирующий)

s->s.chunk(s.len**.5).vfuse

Я добавил .chunkфункцию некоторое время назад, но удалил ее при переходе на новый формат stdlib и забыл добавить ее заново. У Чеддера есть специальный sqrtоператор, но **.5он короче

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

объяснение

s ->              // Function with argument s
    s.chunk(      // Chunk it into pieces of size...
      s.len ** .5 // Square root of length.
    ).vfuse       // Vertical-fuse. Join on newlines
— Downgoat
источник
3

𝔼𝕊𝕄𝕚𝕟, 11 символов / 14 байтов

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Генерируется с помощью этого кода (запускается в консоли браузера переводчика):

c.value=`Ѩ${alias(_,'chunk')}(ï,√ ïꝈ⸩${alias(Array.prototype,'mjoin')}⬮`
— Mama Fun Roll
источник
3

Brainfuck, 83 байта

,[>+[>+<-],]
>
[
  >>[<+<-->>-]
  +<[>+<-]
  <-
]
<<
[
  [<]
  >.,
  >[>]
  >>+>-[<]
  <[[>+<-]++++++++++.,<<]
  <
]

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

Это использует ту же идею, что и Leaky Nun's ответ . Он попросил помочь в игре в гольф в чате, а затем предложил добавить это в качестве нового ответа. (На самом деле то, что я написал в чате, было 84-байтовым решением, очень похожим на это.)

Для сравнения, дополнительный > вначале требуется для реализаций мозгового бездействия, которые не допускают отрицательных адресов памяти.

Как и ожидалось, он находит длину ввода, затем принимает квадратный корень, а затем печатает строки соответственно. Он использует в качестве идеальных квадратов частичные суммы 1 + 3 + 5 ....

— Митч Шварц
источник
3

Brain-Flak , 110 96 байт

([]<>){({}{}(({}[()])))}{}{({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{}{({}<>)<>}<>

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

Второй раствор, 96 байт

(([]<>)<{({}({})({}[()]))}{}>){({}(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>))}{}{}{({}<>)<>}<>

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

объяснение

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

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

{({}[({})({}())])}{}

И это работает, но мы на самом деле хотим две копии отрицательного квадратного корня. Зачем? Нам нужны две копии, потому что мы перебираем строку на двух уровнях: один для создания строк и один для подсчета количества строк. Мы хотим, чтобы оно было отрицательным, поскольку циклы с отрицательными значениями дешевле.

Чтобы сделать это негативным, мы перемещаемся [...]так, чтобы это выглядело так

{({}({})({}[()]))}{}

Чтобы сделать две копии, мы меняемся при появлении попсов

{({}{}(({}[()])))}{}

Теперь, когда у нас есть этот бит, мы можем собрать его вместе с высотой стека, чтобы получить первый кусок кода, который нам нужен.

([]<>){({}{}(({}[()])))}{}

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

Теперь мы строим основной цикл

{({}()<(({})<{({}()<<>({}<>)>)}{}((()()()()()){})>)>)}{}{}

Это довольно просто, мы зацикливаемся n раз каждый раз, перемещая n элементов и закрывая их новой строкой (ASCII 10).

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

{({}<>)<>}<>
— Мастер пшеницы
источник
— H.PWiz
2

Perl 6 , 38 байт

$_=get;.put for .comb: .chars.sqrt.Int

Объяснение:

$_ = get;          # get a single line of input


$_.put             # print with trailing newline

for                # every one of the following:

$_.comb:           # the input split into

$_.chars.sqrt.Int  # chunks of the appropriate size
— Брэд Гилберт b2gills
источник
2

Чеддер, 57 байт

n->(m->(|>m).map(i->n.slice(i*m,i*m+m)).vfuse)(n.len**.5)

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

Кроме того, оказывается, что даже если бы переменные работали, все равно было бы короче использовать лямбда-приложение.

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

cheddar> (n->(m->(|>m).map(i->n.slice(i*m,i*m+m)).vfuse)(n.len**.5))("abcd")
"ab
cd"
— Дрянная Монахиня
источник
2

Java 1.7, 110 байт

void f(String s){for(int i=-1,k=(int)Math.sqrt(s.length());++i<k;)System.out.println(s.substring(i*k,i*k+k));}

Попытайся! (Ideone)

Я попробовал другой подход с функцией, возвращающей результат в виде строки, но просто нужно объявить строку и оператор return уже дороже (в байтовом выражении), чем оператор print.

Должен любить многословие Java ... :)

— Миллигенри
источник
Хороший ответ +1. Вы можете играть в гольф это 1 байт, используя i=0, i<kи s.substring(i*k,i++*k+k)вместо того i=-1, ++i<k, s.substring(i*k,i*k+k). Кроме того, обычно мы используем просто Java 7вместо Java 1.7, но это хорошо, что вы добавили его, многие люди забывают сделать это.
— Кевин Круйссен
2

R , 59 54 байта

function(s)write(el(strsplit(s,'')),1,nchar(s)^.5,,'')

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

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

— Giuseppe
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.