Essayez de faire un cube!

16

Sur cette base: fais-moi un carré!

Vous devez générer ceci:

  ####
 # # #
###  #
# # #
####

Où "#" est remplacé par l'entrée.

Si vous entrez "A", vous devriez obtenir

  AAAA
 A A A
AAA  A
A A A
AAAA

Si vous entrez "&", vous devriez obtenir

  &&&&
 & & &
&&&  &
& & &
&&&&

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

une'_'
la source
5
Eh bien, c'est un peu similaire, bien qu'au moins ce ne soit pas une réponse de 3 octets dans Charcoal cette fois ...
Neil
1
Les deux dernières lignes peuvent-elles avoir des espaces de début et le résultat peut-il avoir des nouvelles lignes de début?
dzaima
3
B³S‖O↗cela peut très bien être proche d'une réponse de 10 octets en fusain ... Je ne connais pas assez bien la langue pour le faire, il doit vraiment y avoir une page comme celle-ci mais pour le charbon.
Urne Magic Octopus
5
@AAlex Sandbox
xnor
6
Je ne vois pas comment c'est un dupe du carré
Luis Mendo

Réponses:

19

Carotte , 31 octets

  ####
 # # #
###  #
# # #
####

#s sont remplacés par l'entrée.

Fondamentalement, un port de cette réponse , à ce problème.

Stephen
la source
40
qui semble avoir mis des heures à
jouer
@KritixiLithos 200 rep parce que vous avez fait un langage cool, cela ne semble pas juste xD
Stephen
13

05AB1E , 16 15 octets

ð‚•nxвΛ•2вèJ6ô»

Essayez-le en ligne!

Explication

ð‚                # push the list [<input>,<space>]
  •nxвΛ•          # push the number 816342339
        2в        # convert to list of base 2 digits
          è       # index into the the 2-char string with this list
           J      # join to string
            6ô    # split into pieces of length 6
              »   # join on newlines
Emigna
la source
1
Pouvez-vous encoder la nouvelle ligne dans la liste / numéro pour enregistrer les 3 derniers octets?
Rod
@Rod Ce serait un nombre beaucoup plus grand, 6 octets au minimum, plus un ou deux octets supplémentaires pour inclure la nouvelle ligne dans la liste ...
ETHproductions
@Rod: Vous pourriez faire quelque chose comme ça . Malheureusement, cela s'avère un peu plus long. Bonne idée cependant.
Emigna
1
•nxвΛ•bTRð¹ì‡6ô»... le vôtre bat légèrement la translittération, uniquement en raison des exigences de commande; si je pouvais trouver un moyen de prendre implicitement l'entrée et de générer la chaîne 01en 1 octet, ce serait une solution de 13/14 octets.
Urne Magic Octopus
1
@carusocomputing •nxвΛ•bT𹫇6ô»ou ð«T•nxвΛ•br‡6ô»est de même longueur.
Emigna
10

Cubix , 62 octets

./v<.o;.@?/;w.w;i:::::NrSs::SrSuUS::sN::rS:r:srNr:SrSsNs:::SSv

Essayez-le en ligne! et regardez l'interprète!

Cela correspond à un 4 cubes:

        . / v <
        . o ; .
        @ ? / ;
        . . w ;
i : : : : : N r S s : : S r S u
U S : : s N : : r S : r : s r N
r : S r S s N s : : : S S v . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

Je ne suis pas très bon pour manipuler la direction du pointeur d'instructions, je vais donc continuer à essayer cela. Ceci et ma réponse ici sont basés sur le "Bonjour, monde!" exemple de programme utilisant ./v.o;@?/(sur un 3-cube) pour imprimer et pop récursivement les caractères sur la pile, donc le reste du code pousse simplement les caractères sur la pile dans le bon ordre.

J'ai maintenant fait un cube sur un cube, donc je peux rester tranquille (et faire mon travail réel).

Giuseppe
la source
9

SOGL , 13 10 octets

Βū&⁵'r⁹‘6n

Explication:

Βū&⁵'r⁹‘    push "  ŗŗŗŗ ŗ ŗ ŗŗŗŗ  ŗŗ ŗ ŗ ŗŗŗŗ", where "ŗ" is replaced with input
        6n  split into lines of length 6
dzaima
la source
1
Comment est-ce assis à 0? Probablement en raison de l'absence d'un TIO ._. +1
Urne de poulpe magique
Je pense qu'il y aura (espérons-le) la plupart des trucs de rupture de mise à jour et ensuite je penserai à quelque chose de courant en ligne
dzaima
6
Fils d'une langue de golf?
ETHproductions
@ETHproductions lol
dzaima
Langue de golf orientée cordes
le
9

MATL , 13 10 octets

Merci à Conor O'Brien d'avoir supprimé 3 octets et de m'avoir montré que les non imprimables peuvent être utilisés dans Octave.

Le code contient des caractères non imprimables. Essayez-le en ligne!

Explication

'....'   % Push 5-char string (contains unprintables). Each char encodes a row
         % of the desired pattern
B        % Convert to binary. Gives a 5×6 binary matrix with the pattern
*        % Implicit input. Multiply element-wise (converts input to ASCII code)
c        % Convert to char. Implicitly display. Char 0 is shown as space
Luis Mendo
la source
Vous pouvez faire ces 10 octets si vous êtes d'accord avec les non imprimables. Essayez-le en ligne!
Conor O'Brien
@ ConorO'Brien Hé, merci! Je n'étais pas sûr qu'Octave était d'accord avec ces ... comment les avez-vous même saisis?
Luis Mendo
Eh bien, honnêtement, j'ai pris les chiffres, les ai convertis en hexadécimal, puis je l'ai fait echo 0f15392a3c|xxd -r -p|clip. Sous Windows, clipc'est le presse-papiers. Ensuite, je les ai juste collées: P (si vous êtes sur une ligne de commande, c'est ^O^Uaussi bien)
Conor O'Brien
@ ConorO'Brien C'est bien au-dessus de ma tête. Vous devriez vraiment poster cela comme votre réponse
Luis Mendo
Il utilise la même tactique que la vôtre, supprimant simplement le besoin de modulo 64 en utilisant directement les valeurs.
Conor O'Brien
6

PHP, 52 octets

<?=strtr("  0000
 0 0 0
000  0
0 0 0
0000",0,$argn);

Essayez-le en ligne!

Jörg Hülsermann
la source
6

Japt , 20 octets

"OUyj|"®c ¤Åd0S1U +R

Testez-le en ligne!

Pas trop mal pour une langue sans compression intégrée (enfin, sauf la compression de chaînes de lettres minuscules) ...

Explication

En binaire, les cinq caractères de la chaîne sont:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

Découpez l'initiale 1de chacun et vous obtenez le modèle du cube.

"OUyj|"®   c ¤  Å  d0S1U +R
"OUyj|"mZ{Zc s2 s1 d0S1U +R}  // Expanded
                              // Implicit: U = input string
"OUyj|"mZ{                 }  // Replace each character Z in this string with this function:
          Zc                  //   Take the char-code of Z.
             s2               //   Convert to a binary string.
                s1            //   Slice off the first character (always a "1").
                   d0S1U      //   Replace "0"s with spaces and "1"s with the input.
                         +R   //   Append a newline.
                              // Implicit: output result of last expression
ETHproductions
la source
J'ai essayé une approche basée sur un modèle ( llpeut être compressée), mais c'est 11 octets de plus.
Luke
Agréable. J'étais à 23 octets avant de réaliser que j'en avais fait des boules!
Shaggy
6

LOLCODE, 202 170 octets

I HAS A c
GIMMEH c
VISIBLE"  "AN c AN c AN c AN c AN":) "AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN"  "AN c AN":)"AN c AN" "AN c AN" "AN c AN":)"AN c AN c AN c AN c

A LOLCODE, pas grand chose au golf ...

Cela définit la variable cdans l'entrée et crée une chaîne concaténée géante comprenant des :)sauts de ligne. C'est à peu près ça.

OldBunny2800
la source
expected HAI at: I tio.run/nexus/…
eush77
En outre, VISIBLEconcatène implicitement, vous pouvez donc supprimer SMOOSH tio.run/nexus/lolcode#@@/…
eush77
Pour votre première chose, il existe des interprètes qui ne nécessitent pas HAI ou KTHXBYE, par exemple REPL.it. Pour votre deuxième chose, merci!
OldBunny2800
5

Sed, 40 caractères

s/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/

Presque tricherie car la description du défi la contenait presque littéralement.

Exemple d'exécution:

bash-4.4$ sed 's/./  &&&&\
 & & &\
&&&  &\
& & &\
&&&&/' <<< 'C'
  CCCC
 C C C
CCC  C
C C C
CCCC

Essayez-le en ligne!

homme au travail
la source
5

Assemblage Z80, code machine 37 octets

Supposons un périphérique d'E / S mappé en mémoire:

; N'ENTREZ PAS D'ESPACE ou il ira dans des espaces d'impression en boucle infinie et des nouvelles lignes!

3A xx xx ld a, (entrée); obtenir le caractère d'entrée
11 0A 20 ld de, 200ah; espace et nouvelle ligne
21 aa aa aa hl, sortie; obtenir l'adresse de sortie
4F ld c, a; mettre du caractère en c
boucle:
72 ld (hl), d; espace de sortie * 2 | caractère de sortie * 2
72 ld (hl), d
77 ld (hl), a; caractère de sortie | caractère de sortie
71 ld (hl), c; caractère de sortie * 2 | espace de sortie * 2
71 ld (hl), c
77 ld (hl), a; caractère de sortie | caractère de sortie
73 ld (hl), e; sortie nouvelle ligne | sortie nouvelle ligne
72 ld (hl), d; espace de sortie | caractère de sortie
71 ld (hl), c; caractère de sortie | espace de sortie
72 ld (hl), d; espace de sortie | caractère de sortie
71 ld (hl), c; caractère de sortie | espace de sortie
72 ld (hl), d; espace de sortie | caractère de sortie
B9 cp c; mettre le drapeau à zéro 1ère fois | clair 2e fois
20 06 jr nz, fin; sauter pour terminer
77 ld (hl), a; caractère de sortie
73 ld (hl), e; sortie nouvelle ligne
4A ld c, d; mettre de l'espace en c
57 ld d, a; mettre du caractère en d
28 FB jr z, boucle; boucle à la 2e fois
fin:
73 ld (hl), e; sortie nouvelle ligne
77 ld (hl), a; caractère de sortie * 4
77 ld (hl), a
77 ld (hl), a
77 ld (hl), a
76 arrêt; ou C9 ret
Dan Howell
la source
4

V , 27 octets

4äl2>>Äyvho3pÄÙ3älWx<<3Îd^

Essayez-le en ligne!

Hexdump:

00000000: 34e4 6c32 3e3e c479 7668 6f1b 3370 c4d9  4.l2>>.yvho.3p..
00000010: 33e4 6c57 783c 3c33 ce64 5e              3.lWx<<3.d^
DJMcMayhem
la source
Je suis sûr que vous pouvez remplacer o<esc>par justeï
Kritixi Lithos
4

PHP, 72 octets

J'ai fait celui-ci juste pour le plaisir, car il existe déjà une meilleure réponse PHP.

for($i=0;$i<27;)echo('00'.decbin(64349871))[$i]?$argn:' ',++$i%6?'':'
';

Le cube est dessiné en obtenant la valeur binaire de 64349871, concaténée par '00'.
Cela renvoie les éléments suivants:

0011110101011110011010101111

Chaque 6ème personnage, j'émets une nouvelle ligne, ce qui se traduit par:

001111
010101
111001
101010
1111

Et, au lieu d'afficher 0, il affiche un espace, qui ressemblera à:

  1111
 1 1 1
111  1
1 1 1 
1111
Ismael Miguel
la source
4

Fusain , 17 16 octets

SβGH7+↗→³β→G↓↙³β

Essayez-le en ligne! Le lien est vers la version détaillée du code. Plus long que je ne le souhaitais, car le "cube" est légèrement plus large que haut ou profond. Heureusement, certains des caractères multidirectionnels fonctionnent avec PolygonHollow, ce qui me fait gagner 3 octets. Edit: enregistré un octet supplémentaire en utilisant + au lieu de T ↑. Explication:

Sβ          Input the character
GH7+↗→³β    Draw the left half. 7 becomes ←↙ and + becomes →↓←↑.
→           Move right one character.
G↓↙³β       Draw the right half.

Au moment du challenge, la qvariable ne fonctionnait pas en mode verbeux, sinon j'aurais pu créer cette version à 14 octets:

GH7+↗→³θ→G↓↙³θ

Essayez-le en ligne!

Neil
la source
3

Empilé , 31 octets

' '\+$'9*<'#.2 tb[6 dpad]map#

Essayez-le en ligne!

Voici un hexdump:

λ xxd try-to-make-a-cube.stk
00000000: 2720 275c 2b24 270f 1539 2a3c 2723 2e32  ' '\+$'..9*<'#.2
00000010: 2074 625b 3620 6470 6164 5d6d 6170 23     tb[6 dpad]map#

Cela convertit un tableau de caractères en binaire, remplit chaque ligne en longueur 6et l'indexe en fonction de la chaîne' ' input +

Conor O'Brien
la source
3

Pyth, 25 22 21 20 octets

jcsm?d\ zjC"0¨eC"2 6

Essayez!

21 octets

t::." \"o½MËñ"\!bNw

Essaye ça!

Aussi 21 octets:

:jbct." \" ±¢î
"6Nw

Essayez ça!

KarlKastor
la source
2

JS (ES6), 64 60 52 octets

i=>`  ####
 # # #
###  #
# # #
####`.replace(/#/g,i)

Cela peut-il être amélioré:

i=>`  ${y=i+i+i+i}
 # # #
###  #
# # #
${y}`.replace(/#/g,i)
programmer5000
la source
1
y=i+i+i+iest plus court quey=i.repeat(4)
Stephen
2
... et ####est encore plus court.
Arnauld
1
En fait, le tout est plus court sans modèles: Fiddle
Stephen
1

C (gcc) , 90 84 octets

i;v;f(g){for(i=32;i--;)putchar((v="####*@#@#@#*#@@###*#@#@#@*####@@"[i])&1?g:v-32);}

Essayez-le en ligne!Définit une fonction fqui prend un caractère g. Dommage que l'encodage direct de la table soit plus court ...

Ancienne version, 90 octets

(J'essaie toujours de jouer au golf)

Essayer d'avoir un seul putchar, mais idk. Il y a des non imprimables, voici donc l'hexdump:

λ xxd try-to-make-a-cube.c
00000000: 693b 6a3b 6628 6729 7b63 6861 722a 6b3d  i;j;f(g){char*k=
00000010: 220f 1539 2a3c 223b 666f 7228 693d 303b  "..9*<";for(i=0;
00000020: 693c 353b 7075 7463 6861 7228 3130 292c  i<5;putchar(10),
00000030: 692b 2b29 666f 7228 6a3d 3332 3b6a 3b6a  i++)for(j=32;j;j
00000040: 2f3d 3229 7075 7463 6861 7228 6b5b 695d  /=2)putchar(k[i]
00000050: 266a 3f67 3a33 3229 3b7d                 &j?g:32);}

Cela code le cube dans une table de recherche binaire, où un 1bit représente l'entrée et un 0bit représente un espace. Essayez-le en ligne!

Conor O'Brien
la source
Peut raser quelques octets pour 81 octets .
gastropner
Celui non imprimable peut être réduit à 73 octets .
gastropner
1

Brain-Flak , 217 octets

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

Essayez-le en ligne!

Waaaaay trop longtemps.

DJMcMayhem
la source
1

Swift - 82 octets + Foundation (18 octets)?

var f={"  ####\n # # #\n###  #\n# # #\n####".replacingOccurrences(of:"#",with:$0)}

Par défaut, les projets Xcode-Swift ont Whole-Module Optimization , ce qui import Foundationn'est pas requis pour cette simple fonction de type lambda. Cependant, son exécution dans des environnements en ligne l'exige, ce qui peut ajouter 18 octets.

Vérifiez-le!

M. Xcoder
la source
1

Java 8, 55 octets

c->"  ####\n # # #\n###  #\n# # #\n####".replace('#',c) 

Essayez-le ici.

Java 7, 77 octets

String c(char c){return"  ####\n # # #\n###  #\n# # #\n####".replace('#',c);}

Essayez-le ici.

Kevin Cruijssen
la source
0

CJam, 23 octets

"pjFUC"{i2b(;}%rS+ff=N*

Je sens que je peux encore jouer au golf.

"pjFUC" e# String literal:          │ "pjFUC"
{       e# For each:                │ 'p
  i     e#   Get code point:        │ 112
  2b    e#   To binary:             │ [1 1 1 0 0 0 0]
  (;    e#   Delete first:          │ [1 1 0 0 0 0]
}%      e# End                      │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]]
r       e# Read token:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&"
S       e# Push space:              │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "&" " "
+       e# Concatenate:             │ [[1 1 0 0 0 0] [1 0 1 0 1 0] [0 0 0 1 1 0] [0 1 0 1 0 1] [0 0 0 0 1 1]] "& "
ff=     e# Vectorized array lookup: │ ["  &&&&" " & & &" "&&&  &" "& & & " "&&&&  "]
N*      e# Join with newlines       │ "  &&&&
        e#                          │   & & &
        e#                          │  &&&  &
        e#                          │  & & & 
        e#                          │  &&&&  "
e# Implicit output
Esolanging Fruit
la source
0

dc , 70 octets

Encode la séquence plutôt directement, avec une optimisation mineure:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

Essayez-le en ligne!


Pris à un extrême (pas très golfique), 145 octets:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

Essayez-le en ligne!

Cela calcule A*x+B, où Acode les positions du caractère d'entrée et Bcode tout le reste:

A = 256 0 + 256 1 + 256 2 + 256 3 + 256 5 + 256 7 + 256 9 + 256 11 + 256 14 + 256 15 + 256 16 + 256 18 + 256 20 + 256 22 + 256 25 + 256 26 + 256 27 + 256 28

B = 10 × 256 4 + 32 × 256 6 + 32 × 256 8 + 10 × 256 10 + 32 × 256 12 + 32 × 256 13 + 10 × 256 17 + 32 × 256 19 + 32 × 256 21 + 32 × 256 23 + 10 × 256 24 + 32 × 256 29 + 32 × 256 30

P La commande imprime le nombre résultant sous la forme d'un flux d'octets.

eush77
la source
0

C #, 53 octets

c=>@"  ####
 # # #
###  #
# # #
####".Replace('#',c);
TheLethalCoder
la source
0

Lot Windows, 79 octets

@echo   %1%1%1%1
@echo  %1 %1 %1
@echo %1%1%1  %1
@echo %1 %1 %1
@echo %1%1%1%1

Caractère spécial. sûr, 97 octets:

@echo   ^%1^%1^%1^%1
@echo  ^%1 ^%1 ^%1
@echo ^%1^%1^%1  ^%1
@echo ^%1 ^%1 ^%1
@echo ^%1^%1^%1^%1
stevefestl
la source
Pouvez-vous utiliser des .. %1%1%1%1\n %1 %1 %1...
sauts de
Les
sauts de
Je ne me souvenais pas s'ils l'étaient ou non et n'étaient pas en mesure de tester :)
TheLethalCoder
Désolé, je suis confus, pouvez-vous répéter?
stevefestl
Je ne me souvenais pas si vous pouviez les utiliser ou non et je ne pouvais pas tester au moment où j'ai commenté alors j'ai laissé le commentaire pour que vous ayez toujours l'idée
TheLethalCoder
0

Tcl, 60 octets

proc c x {regsub . $x "  &&&&\n & & &\n&&&  &\n& & &\n&&&&"}
avl42
la source