Un carré de texte

29

Le défi

Étant donné une chaîne, affichez le texte sous la forme d'un carré.

Vous pouvez supposer que le texte tiendra toujours dans un carré et qu'il ne s'agira jamais d'une chaîne vide.

Vous pouvez également supposer qu'il n'aura jamais de nouvelles lignes.

Exemple

Input:
Hi, world

Output:
Hi,
 wo
rld

Cas de test

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

Règles

  • C'est le golf de code , donc la réponse la plus courte en octets gagne! Tiebreaker est la réponse la plus votée.
  • Les failles standard sont interdites.
code-golf string grid acrolithe
la source
Pouvons-nous supposer que l'entrée n'aura jamais de nouvelles lignes?
MayorMonty
@MayorMonty yep.
acrolith
2
Pouvons-nous produire un tableau de chaînes à la place?
Leaky Nun
@LeakyNun no 15 chars
acrolith
2
Pouvons-nous imprimer avec une nouvelle ligne de fin?
Giuseppe

Réponses:

21

Vim, 59, 57 , 48 octets / touches

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

Étant donné que V est rétrocompatible, vous pouvez l' essayer en ligne!

J'ai reçu au hasard un vote positif sur cette réponse, alors j'ai relu. Mes compétences en golf sur vim ont considérablement augmenté au cours des 7 derniers mois, j'ai donc vu que cette réponse était très mal jouée. Celui-ci est bien meilleur.

DJMcMayhem
la source
15

Brainfuck , 116 112 bytes

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

Essayez-le en ligne!

Coffre-fort dans les saveurs de BF qui ne masque pas les cellules avec 256, ne prend pas en charge les octets nuls.

Supprimez les flèches de droite initiales si l'arôme prend en charge la mémoire négative pour 4 octets enregistrés.

Explication

Le programme est divisé en 3 étapes:

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

Étape 1

Dans cette étape, nous mettons tous les personnages sur la bande, tout en comptant le nombre de caractères.

Ceci est la bande pour l'entrée abcdefghiaprès cette bande:

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

C'est 009le comte.

Pour chaque caractère, nous déplaçons le premier zéro à gauche [<], puis nous ajoutons un au nombre <<+>>>, puis nous nous déplaçons vers le zéro le plus [>]à droite pour nous préparer pour le caractère suivant.

Étape 2

Cette étape fait la racine carrée de la longueur stockée dans la deuxième cellule.

Il continue de soustraire 1, 3, 5, 7, ...jusqu'à ce que le nombre atteigne zéro, tout en vérifiant le nombre d'itérations.

Cela fonctionne parce que les nombres carrés peuvent être exprimés comme 1 + 3 + 5 + ....

Étape 3

Désigner la racine carrée de la longueur trouvée ci-dessus comme n.

Cette étape produit des ncaractères à la fois, puis génère une nouvelle ligne, jusqu'à ce que la bande soit effacée.

Leaky Nun
la source
1
+1 n'a pas été lu semble incroyable
Rohan Jhunjhunwala
11

Python 2, 55 octets

s=input()
n=int(len(s)**.5)
while s:print s[:n];s=s[n:]
xnor
la source
10

05AB1E , 5 octets

Dgtô«

Essayez-le en ligne!

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)
acrolithe
la source
1
Très bonne réponse. Mais comment ça fonctionne? Pourriez-vous modifier pour ajouter une explication?
grooveplex
@grooveplex done.
acrolith
Très impressionnant!
Gryphon - Rétablir Monica le
3
C'est bizarre de voir les anciennes réponses 05AB1E où en »sont les nouvelles lignes maintenant.
Magic Octopus Urn
8

MATL , 6 octets

tnX^e!

Essayez-le en ligne!

Explication

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
Luis Mendo
la source
1
"toor" carré? : P
acrolith
@daHugLenny :-D. Corrigé
Luis Mendo
4
@daHugLenny C'est l'inverse de la racine carrée. ;-)
WBT
7

Gelée, 8 7 octets

sLƽ$j⁷

Enregistré un octet grâce à @ Dennis .

Essayez-le en ligne.

Explication

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
miles
la source
2
œset sfaites la même chose ici.
Dennis
Pourquoi ne ½fonctionne pas à la place de ƽ?
Luis Mendo
@LuisMendo Parce qu'il renvoie un flottant. Je vais patcher set œsdonc ils ont casté en int.
Dennis
@Dennis patch attendu depuis longtemps toujours en attente ...
Erik the Outgolfer
7

JavaScript (ES7), 49 octets

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

44 octets dans Firefox Nightly 43-46 uniquement (a **été introduit quelque temps entre Firefox Nightly 42 et 43 et gun paramètre distinct a été supprimé quelque temps entre Firefox Nightly 46 et 47):

s=>s.match(`.{${s.length**.5}}`,`g`).join`
`
Neil
la source
Dans la première version pourquoi avez - vous besoin +danss.length*+.5
Downgoat
Je n'ai jamais vu la *+syntaxe auparavant. Quelqu'un pourrait-il l'expliquer?
MayorMonty
Il veut probablement dire **.
Conor O'Brien
@MayorMonty Ouais c'était une faute de frappe désolé.
Neil
@Downgoat C'était une faute de frappe.
Neil
7

J, 9 octets

$~,~@%:@#

Il s'agit d'un crochet monadique sur la chaîne d'entrée:

$~ ,~@%:@#

La bonne dent est une série de compositions:

,~ @ %: @ #

La gauche est un verbe de mise en forme, commuté de telle sorte qu'il fonctionne au format crochet.

Voici quelques résultats intermédiaires:

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

Dans les mots:

   size =: #
   sqrt =: %:
   dup =: ,~
   on =: @
   shape =: $~
   block =: shape dup on sqrt on size
   block 'Hello, World! :)'
Hell
o, W
orld
! :)
Conor O'Brien
la source
2
J'aime le fait que cela $~,~@ressemble à une sorte d'émoticône mais @semble bizarre pour une oreille mais &s'adapte mieux, ou$~,~&
miles
1
Et je suppose qu'ils sont fonctionnellement équivalents. Enfin, surtout. L'un vous permet de mieux entendre que l'autre;)
Conor O'Brien
1
+1 pour que votre score soit n². Le mien l'est aussi :)
Digital Trauma
@DigitalTrauma fun! +1 de même!
Conor O'Brien
1
$~2#%:@#est 8. La partie gauche d'une fourche peut être une constante.
FrownyFrog
5

C, 64 octets

Appelez f()avec la chaîne au carré.

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

Essayez-le sur ideone .

owacoder
la source
1
Pouvez-vous le faire fonctionner avec un intargument implicite au lieu de char*?
anatolyg
Je ne pense pas. Il doit être déréférencé, donc un type numérique ne fonctionnera pas, et il ne peut pas être un int*car cela pourrait mal évoluer lors de l'ajout.
owacoder
Suggérer à la s+=write(puts(""),s,m));place des+=m)printf("%.*s\n",m,s);
plafondcat
5

Perl, 23 + 4 ( -pFdrapeaux) = 27 octets

-2 octets grâce à @DomHastings
-1 octets grâce à @DomHastings

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

Essayez-le en ligne!

Expansions : calcule la racine carrée (appelons-la Spour l'explication) de la taille de l'entrée (ce sera toujours un entier) ( @Fest utilisée dans un contexte scalaire, retournant ainsi sa taille), puis ajoutez une nouvelle ligne après chaque bloc de Spersonnages.

Dada
la source
Belle utilisation de $@,;) Vous pouvez enregistrer un octet en utilisant y///cau lieu de la longueur et je pense que vous pouvez également utiliser une nouvelle ligne littérale. Je cherchais à essayer de faire quelque chose avec le réglage $,et la correspondance, mais je pense que c'est beaucoup plus court!
Dom Hastings
1
@DomHastings Oui, je pensais que vous aimeriez le $@! Merci pour le y///c, j'ai tendance à oublier qu'il existe.
Dada
1
@DomHastings a réussi à économiser 1 octet en utilisant à la $=place de $@, ce qui permet de ne pas utiliser d' -lindicateur.
Dada
Bon déroulement! Bon d'utiliser aussi les variables magiques pour de vraies raisons!
Dom Hastings du
Hé, j'espère que tu vas bien! Cela a été renvoyé à la page d'accueil et j'ai remarqué une autre optimisation pour le code-pF
Dom Hastings
4

zsh, 36 octets

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

Prend l'entrée comme argument de ligne de commande, renvoie à 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
Poignée de porte
la source
+1 pour que votre score soit n². Le mien l'est aussi :)
Digital Trauma
4

05AB1E , 8 6 octets

Merci à @quartata de m'avoir informé de la fonction racine carrée

Dgtô¶ý

Essayez-le en ligne!

Explication

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
Luis Mendo
la source
Très agréable! En outre, «c'est court pour rejoindre sur les nouvelles lignes :).
Adnan
1
@Adnan Merci! Maintenant, je me suis surpassé :-D
Luis Mendo
Je suis revenu à ma version 6 octets car il y avait une réponse précédente avec«
Luis Mendo
1
Oh, c'est dommage :(
Adnan
Quelqu'un d'autre a-t-il l'impression que ces langages spécialement créés pour le golf de code ruinent un peu l'attrait de tout cela?
René Roth
4

Python, 94 75 71 65 63 octets

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

Ancienne version:

lambda r:"\n".join(map("".join,zip(*[iter(r)]*int(len(r)**.5))))
acrolithe
la source
Notez que vous pouvez utiliser input() par défaut pour recevoir des entrées entre guillemets, sauf si vous souhaitez supprimer spécifiquement cette option.
xnor
@xnor Oh wow, il y a quelques jours je me demandais si je pouvais utiliser des guillemets en entrée ...
acrolith
Ne serait-il pas plus court d'utiliser une lambda?
Leaky Nun
@LeakyNun true ...
acrolith
3

CJam , 8 octets

l_,mQ/N*

Essayez-le en ligne!

Explication

l     e# Read line from input
_,    e# Duplicate. Get length 
mQ    e# Integer square root
/     e# Split into pieces of that size
N*    e# Join by newline. Implicitly display
Luis Mendo
la source
3

Pyth, 8 octets

jcs@lQ2Q

Essayez-le en ligne

Comment ça marche

    lQ     length of input
   @  2    square root
  s        floor
 c     Q   chop input into that many equal pieces
j          join on newline
Anders Kaseorg
la source
3

Dyalog APL, 10 octets

⊢⍴⍨2⍴.5*⍨≢

Explication:

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

Tests:

      (⊢⍴⍨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
marinus
la source
3

Cheddar, 27 octets (non concurrent)

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

J'ai ajouté la .chunkfonction il y a quelque temps mais je l'ai supprimée lors de la transition vers le nouveau format stdlib et j'ai oublié de la rajouter. Cheddar a un sqrtopérateur dédié mais **.5est plus court

Essayez-le en ligne!

Explication

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
la source
3

Utilitaires Bash + GNU, 25

fold -`dc -e${#1}vp`<<<$1

Pas si différent de la réponse de @ Doorknob , mais dcc'est un moyen plus court pour obtenir la racine carrée.

Traumatisme numérique
la source
3

𝔼𝕊𝕄𝕚𝕟, 11 caractères / 14 octets

ѨĊ(ï,√ ïꝈ⸩Ė⬮

Try it here (ES6 browsers only).

Généré à l'aide de ce code (exécuté dans la console du navigateur de l'interpréteur):

c.value=`Ѩ${alias(_,'chunk')}(ï,√ ïꝈ⸩${alias(Array.prototype,'mjoin')}⬮`
Mama Fun Roll
la source
3

Brainfuck, 83 octets

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

Essayez-le en ligne!

Cela utilise la même idée que la réponse de Leaky Nun . Il a demandé de l'aide pour jouer au golf dans le chat, puis m'a suggéré d'ajouter ceci comme nouvelle réponse. (En fait, ce que j'ai écrit dans le chat était une solution de 84 octets très similaire à cela.)

Par souci de comparaison, un supplément >est nécessaire au début pour les implémentations brainfuck qui n'autorisent pas les adresses mémoire négatives.

Comme prévu, cela trouve la longueur de l'entrée, puis prend la racine carrée, puis imprime les lignes en conséquence. Il profite de carrés parfaits étant des sommes partielles de 1 + 3 + 5 ....

Mitch Schwartz
la source
3

Brain-Flak , 110 96 octets

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

Essayez-le en ligne!

Deuxième solution, 96 octets

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

Essayez-le en ligne!

Explication

Ici, j'explique la première solution, les deux sont de la même longueur mais j'aime la première car elle est plus fraîche et utilise de belles astuces.

La partie la plus importante du code est une fonction de racine carrée modifiée que j'ai écrite il y a quelque temps. La version originale était

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

Et cela fonctionne, mais nous voulons en fait deux copies de la racine carrée négative. Pourquoi? Nous avons besoin de deux copies car nous parcourons la chaîne à deux niveaux, un pour créer les lignes et un pour compter le nombre de lignes. Nous voulons qu'il soit négatif parce que boucler avec des négatifs est moins cher.

Pour rendre ce négatif, nous nous déplaçons de [...]sorte qu'il ressemble à ceci

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

Pour faire deux copies, nous changeons lorsque des pops se produisent

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

Maintenant que nous avons ce bit, nous pouvons l'associer à une hauteur de pile pour obtenir le premier morceau de code dont nous avons besoin.

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

Nous passons au offstack parce que notre fonction racine carrée a besoin de deux zéros gratuits pour le calcul, et parce que cela rend les choses un peu moins chères dans le futur en termes de changement de pile.

Maintenant, nous construisons la boucle principale

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

C'est assez simple, nous bouclons n fois à chaque fois en déplaçant n éléments et en les coiffant d'une nouvelle ligne (ASCII 10).

Une fois la boucle terminée, nous devons inverser l'ordre de notre sortie, nous plaçons donc simplement une construction inverse standard.

{({}<>)<>}<>
Assistant de blé
la source
Aussi 96
H.PWiz
2

PHP, 51 octets

<?=join("
",str_split($x=$argv[1],strlen($x)**.5));
Alex Howansky
la source
2

Perl 6 , 38 octets

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

Explication:

$_ = 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
Brad Gilbert b2gills
la source
2

Cheddar, 57 octets

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

Puisque les variables sont cassées, je devrais passer des variables via l'application lambda.

En outre, il s'avère que même si les variables fonctionnaient, il serait encore plus court d'utiliser l'application lambda.

Usage

cheddar> (n->(m->(|>m).map(i->n.slice(i*m,i*m+m)).vfuse)(n.len**.5))("abcd")
"ab
cd"
Leaky Nun
la source
2

Java 1.7, 110 octets

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

Essayez!(Ideone)

J'ai essayé une autre approche avec une fonction renvoyant le résultat sous forme de chaîne, mais le simple fait de déclarer la chaîne et l'instruction de retour est déjà plus cher (en nombre d'octets) que l'instruction print.

Je dois aimer la verbosité de Java ... :)

MH.
la source
Belle réponse +1. Vous pouvez jouer au golf par 1 octet en utilisant i=0, i<ket au s.substring(i*k,i++*k+k)lieu de i=-1, ++i<k, s.substring(i*k,i*k+k). En outre, nous utilisons généralement juste Java 7au lieu de Java 1.7, mais il est bon que vous l'ayez ajouté, beaucoup de gens oublient de le faire.
Kevin Cruijssen
2

R , 59 54 octets

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

Essayez-le en ligne!

Imprime avec une nouvelle ligne de fin. Étonnamment court, compte tenu de la mauvaise gestion des chaînes par R.

Giuseppe
la source
1

Convexe , 7 octets

_,mQ/N*

Essayez-le en ligne!

Fait amusant:

_,mQ/\* fonctionne également sur TIO en raison de son fonctionnement.

Comment ai-je oublié de créer une racine carrée de 1 caractère?

GamrCorps
la source