एक घन बनाने की कोशिश करो!


16

इसके आधार पर: मुझे एक वर्ग बनाओ!

आपको इसका उत्पादन करने की आवश्यकता है:

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

जहां "#" इनपुट के साथ प्रतिस्थापित किया गया है।

यदि आप "ए" इनपुट करते हैं, तो आपको प्राप्त करना चाहिए

  AAAA
 A A A
AAA  A
A A A
AAAA

यदि आप "&" इनपुट करते हैं, तो आपको प्राप्त करना चाहिए

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

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।


5
खैर, यह कुछ हद तक समान है, हालांकि कम से कम इस बार चारकोल में यह 3-बाइट का जवाब नहीं है ...
नील

1
क्या पिछली दो पंक्तियों में अग्रणी स्थान हो सकते हैं और क्या परिणाम में अग्रणी सीमाएँ हो सकती हैं?
द्विजिमा

3
B³S‖O↗यह बहुत अच्छी तरह से चारकोल में एक 10 बाइट उत्तर के करीब हो सकता है ... हालांकि, मैं अभी यह करने के लिए अच्छी तरह से भाषा नहीं जानता कि वास्तव में इस तरह एक पृष्ठ होने की जरूरत है , लेकिन लकड़ी का कोयला के लिए।
मैजिक ऑक्टोपस Urn

5
@ एलेक्स सैंडबॉक्स
xnor

6
मैं यह नहीं देखता कि यह वर्ग एक का एक प्रकार है
लुइस मेंडो

जवाबों:


19

गाजर , 31 बाइट्स

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

#s इनपुट द्वारा प्रतिस्थापित किए गए हैं।

मूल रूप से इस समस्या के लिए, इस जवाब का एक बंदरगाह ।


40
ऐसा लगता है कि यह गोल्फ में घंटे लग गए ...
Cyoce

@KritiiLithos 200 प्रतिनिधि क्योंकि आपने एक शांत भाषा बनाई, यह उचित नहीं प्रतीत होता है xD
स्टीफन

13

05AB1E , 16 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

ð‚                # 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

1
क्या आप अंतिम 3 बाइट्स को बचाने के लिए सूची / संख्या के भीतर नई लाइन को एनकोड कर सकते हैं?
रॉड

@ यह बहुत बड़ी संख्या होगी, बहुत कम से कम 6 बाइट्स, प्लस एक अतिरिक्त बाइट या दो सूची में नई
पंक्ति

@Rod: आप की तरह कुछ कर सकता है यह । दुर्भाग्य से यह थोड़ा लंबा हो गया है। हालांकि अच्छा विचार है।
एमिगा

1
•nxвΛ•bTRð¹ì‡6ô»... तुम्हारा धड़कना थोड़ा अनूदित है, केवल आदेश आवश्यकताओं के कारण; अगर मैं एक तरह से इनपुट लेने और 011-बाइट में स्ट्रिंग उत्पन्न करने का तरीका समझ सकता हूं , तो यह एक 13/14 बाइट समाधान होगा।
मैजिक ऑक्टोपस Urn

1
@ कोरसोमोमप्यूटिंग •nxвΛ•bT𹫇6ô»या ð«T•nxвΛ•br‡6ô»समान लंबाई है।
इमिग्ना

10

क्यूबिक्स , 62 बाइट्स

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

इसे ऑनलाइन आज़माएं! और दुभाषिया देखो!

यह 4-घन पर फिट बैठता है:

        . / 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 . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

मैं निर्देश सूचक की दिशा में हेरफेर करने में बहुत अच्छा नहीं हूं, इसलिए मैं इसे जारी रखने की कोशिश करूंगा। यहाँ और मेरा उत्तर दोनों "हैलो, वर्ल्ड!" पर आधारित हैं उदाहरण के लिए प्रोग्राम ./v.o;@?/(3-क्यूब पर) का उपयोग करके पुनरावृत्ति को स्टैक पर वर्णों को प्रिंट और पॉप करें, इसलिए कोड के बाकी हिस्सों को सही क्रम में स्टैक पर केवल पात्रों को धकेलना है।

मैंने अब एक घन पर एक घन बनाया है, इसलिए मैं आराम कर सकता हूं (और अपना वास्तविक काम कर सकता हूं)।


9

एसओजीएल , 13 10 बाइट्स

Βū&⁵'r⁹‘6n

स्पष्टीकरण:

Βū&⁵'r⁹‘    push "  ŗŗŗŗ ŗ ŗ ŗŗŗŗ  ŗŗ ŗ ŗ ŗŗŗŗ", where "ŗ" is replaced with input
        6n  split into lines of length 6

1
यह 0 पर कैसे बैठा है? संभवतः TIO ._ की कमी के कारण। +1
मैजिक ऑक्टोपस Urn

मुझे लगता है कि वहाँ (उम्मीद है) सबसे अधिक 1 अद्यतन करने वाला सामान होने वाला है और फिर मैं कुछ ऑनलाइन चल रही चीज़ों के बारे में
सोचूंगा

6
एक गोल्फ भाषा का बेटा?
ETHproductions

@ETHproductions lol
dzaima

स्ट्रिंग ओरिएंटेड गोल्फिंग लैंग्वेज

9

MATL , 13 10 बाइट्स

कॉनर ओ'ब्रायन को 3 बाइट्स निकालने के लिए धन्यवाद, और मुझे यह दिखाने के लिए कि ऑक्टेव में unprintables का उपयोग किया जा सकता है।

कोड में अनपेक्षित वर्ण हैं। इसे ऑनलाइन आज़माएं!

व्याख्या

'....'   % 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

यदि आप unprintables से ठीक हैं, तो आप इसे 10 बाइट्स बना सकते हैं। इसे ऑनलाइन आज़माएं!
कॉनर ओ'ब्रायन

@ ConorO'Brien अरे, धन्यवाद! मुझे यकीन नहीं था कि ऑक्टेव उन लोगों के साथ ठीक था ... आपने उन्हें कैसे टाइप किया?
लुइस मेंडो

खैर, मैंने ईमानदारी से संख्याएँ लीं, उन्हें हेक्स में परिवर्तित किया, फिर किया echo 0f15392a3c|xxd -r -p|clip। खिड़कियों पर, clipक्लिपबोर्ड है। तब मैंने सिर्फ उन्हें चिपकाया: पी (यदि आप एक कमांड लाइन पर हैं, तो यह ^O^Uभी है)
कॉनर ओ'ब्रायन

@ ConorO'Brien मेरे सिर के ऊपर रास्ता है। आपको वास्तव में अपने उत्तर के रूप में पोस्ट करना चाहिए
लुइस मेंडो

यह उसी तरह की रणनीति का उपयोग करता है जैसा कि आप करते हैं, बस सीधे मानों का उपयोग करके modulo 64 की आवश्यकता को हटा दें।
कॉनर ओ'ब्रायन


6

जाप , 20 बाइट्स

"OUyj|"®c ¤Åd0S1U +R

इसे ऑनलाइन टेस्ट करें!

बिना बिल्ट-इन कम्प्रेशन के साथ एक भाषा के लिए बहुत बुरा नहीं है (अच्छी तरह से, निचले अक्षरों के तार को छोड़कर) ...

व्याख्या

बाइनरी में, स्ट्रिंग में पाँच वर्ण हैं:

O 1001111
U 1010101
y 1111001
j 1101010
| 1111100

1प्रत्येक से प्रारंभिक बंद स्लाइस करें , और आपको क्यूब के लिए पैटर्न मिलता है।

"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

मैंने एक टेम्पलेट-आधारित दृष्टिकोण ( llसंपीड़ित किया जा सकता है) की कोशिश की, लेकिन यह 11 बाइट्स लंबा है।
ल्यूक

अच्छा लगा। इससे पहले कि मुझे लगता कि मैं इसकी एक गेंद बना देता, मैं 23 बाइट्स तक नीचे था!
झबरा

6

LOLCODE, 202 170 बाइट्स

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

LOLCODE में, गोल्फ से ज्यादा नहीं ...

यह चर cको इनपुट में सेट करता है , और नए सिरे से एक विशाल कंक्रीनेटेड स्ट्रिंग बनाता :)है। यह इसके बारे में।


expected HAI at: I tio.run/nexus/…
eush77

इसके अलावा, संक्षेप मेंVISIBLE , इसलिए आप SMOOSH tio.run/nexus/lolcode#@@/…
eush77

आपकी पहली बात के लिए, कुछ व्याख्याकार हैं जिन्हें HAI या KTHXBYE की आवश्यकता नहीं है, जैसे REPL.it. अपनी दूसरी बात के लिए, धन्यवाद!
OldBunny2800



5

Z80 विधानसभा, 37 बाइट्स मशीन कोड

मान लें कि मैंने मैप किया I / O डिवाइस:

; एक अंतरिक्ष में शामिल नहीं है या यह अनंत लूप प्रिंटिंग स्पेस और नई सुर्खियों में जाएगा!

3 ए xx xx ld ए, (इनपुट); इनपुट चरित्र प्राप्त करें
11 0 ए 20 एल डी, 200 एए; अंतरिक्ष और newline
21 yy yy ld hl, आउटपुट; आउटपुट पता प्राप्त करें
4 एफ एलडी सी, ए; c में चरित्र डालें
पाश:
72 एलडी (एचएल), डी; आउटपुट स्पेस * 2 | आउटपुट चरित्र * २
72 एलडी (एचएल), डी
77 एलडी (एचएल), ए; आउटपुट चरित्र | आउटपुट चरित्र
71 एलडी (एचएल), सी; आउटपुट चरित्र * 2 | आउटपुट स्पेस * २
71 एलडी (एचएल), सी
77 एलडी (एचएल), ए; आउटपुट चरित्र | आउटपुट चरित्र
73 एलडी (एचएल), ई; आउटपुट न्यूलाइन | आउटपुट न्यूलाइन
72 एलडी (एचएल), डी; आउटपुट स्पेस | आउटपुट चरित्र
71 एलडी (एचएल), सी; आउटपुट चरित्र | उत्पादन स्थान
72 एलडी (एचएल), डी; आउटपुट स्पेस | आउटपुट चरित्र
71 एलडी (एचएल), सी; आउटपुट चरित्र | उत्पादन स्थान
72 एलडी (एचएल), डी; आउटपुट स्पेस | आउटपुट चरित्र
बी 9 सीपी सी; शून्य ध्वज 1 बार सेट करें | 2 बार साफ़ करें
20 06 jr nz, अंत; समाप्त करना छोड़ें
77 एलडी (एचएल), ए; आउटपुट चरित्र
73 एलडी (एचएल), ई; आउटपुट न्यूलाइन
4 ए एलडी सी, डी; c में जगह दें
57 एलडी डी, ए; d में चरित्र डालें
28 एफबी जूनियर जेड, लूप; 2 बार
समाप्त:
73 एलडी (एचएल), ई; आउटपुट न्यूलाइन
77 एलडी (एचएल), ए; आउटपुट चरित्र * ४
77 एलडी (एचएल), ए
77 एलडी (एचएल), ए
77 एलडी (एचएल), ए
76 पड़ाव; या सी 9 रिटायर


4

PHP, 72 बाइट्स

मैंने इसे केवल मज़े के लिए बनाया है, क्योंकि पहले से ही बेहतर PHP उत्तर है।

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

क्यूब का द्विआधारी मान प्राप्त करके खींचा जाता है 64349871, द्वारा संघनन '00'
यह निम्नलिखित देता है:

0011110101011110011010101111

हर 6 वाँ पात्र, मैं एक नई पंक्ति का उत्पादन कर रहा हूँ, जिसके परिणामस्वरूप:

001111
010101
111001
101010
1111

और, प्रदर्शित करने के बजाय 0, यह एक स्थान प्रदर्शित करता है, जो ऐसा दिखेगा:

  1111
 1 1 1
111  1
1 1 1 
1111

4

चारकोल , 17 16 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। लंबे समय से मैं चाहता था कि यह हो, क्योंकि "घन" लंबा या गहरा होने की तुलना में थोड़ा व्यापक है। सौभाग्य से कुछ मल्टीडायरेक्शनल कैरेक्टर पॉलीगॉनहोल के साथ काम करते हैं, जो मुझे 3 बाइट्स बचाता है। संपादित करें: T Sav के बजाय + का उपयोग करके एक और बाइट को बचाया। स्पष्टीकरण:

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

चुनौती के समय, qचर क्रिया मोड में काम नहीं करता था, अन्यथा मैं यह 14-बाइट संस्करण बना सकता था:

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

इसे ऑनलाइन आज़माएं!


3

स्टैक्ड , 31 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यहाँ एक हेक्सडम्प है:

λ 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#

यह एक वर्ण सरणी को बाइनरी में कनवर्ट करता है, प्रत्येक पंक्ति को लंबाई तक पैड 6करता है, और स्ट्रिंग के अनुसार इसे अनुक्रमित करता है' ' input +



2

जेएस (ईएस 6), 64 60 52 बाइट्स

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

क्या इसमें सुधार किया जा सकता है:

i=>`  ${y=i+i+i+i}
 # # #
###  #
# # #
${y}`.replace(/#/g,i)

1
y=i+i+i+iसे कम हैy=i.repeat(4)
स्टीफन

2
... और ####भी छोटा है।
Arnauld

1
वास्तव में टेम्प्लेट के बिना पूरी चीज छोटी है: फिडल
स्टीफन

1

सी (जीसीसी) , 90 84 बाइट्स

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

इसे ऑनलाइन आज़माएं! एक फ़ंक्शन को परिभाषित करता है fजो एक चरित्र लेता है g। बहुत बुरा टेबल सीधे छोटा है एन्कोडिंग ...

पुराना संस्करण, 90 बाइट्स

(अभी भी यह एक गोल्फ की कोशिश कर रहा है)

केवल एक ही है putchar, लेकिन आईडी की कोशिश कर रहा । यहां अप्रमाणिकाएं हैं, इसलिए यहां हेक्सडंप है:

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

यह क्यूब को एक बाइनरी लुकअप टेबल में एन्कोड करता है, जहां एक 1बिट इनपुट का प्रतिनिधित्व करता है और 0थोड़ा स्पेस का प्रतिनिधित्व करता है। इसे ऑनलाइन आज़माएं!


81 बाइट्स के लिए कुछ बाइट्स को शेव कर सकते हैं ।
गैस्ट्रोपनर

एक unprintables 73 बाइट्स के लिए निचोड़ा जा सकता है ।
गैस्ट्रोपनर


1

स्विफ्ट - 82 बाइट्स + फाउंडेशन (18 बाइट्स)?

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

डिफ़ॉल्ट रूप से, Xcode-Swift प्रोजेक्ट्स हैं Whole-Module Optimization, ताकिimport Foundation इस साधारण लैम्ब्डा जैसे फ़ंक्शन के लिए आवश्यक नहीं है। हालाँकि, इसे ऑनलाइन वातावरण में चलाने के लिए इसकी आवश्यकता होती है, जिसमें 18 बाइट्स शामिल हो सकते हैं।

इसकी जांच - पड़ताल करें!



0

सीजेएम, 23 बाइट्स

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

मुझे लगता है कि मैं अभी भी इसे गोल्फ कर सकता हूं।

"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

0

डीसी , 70 बाइट्स

मामूली अनुकूलन के साथ सीधे अनुक्रम को एनकोड करता है:

8224PdPdPdPdP10Pd8192+ddPPP10PdPdPdP8224PdP10Pd256*32+ddPPP10PdPdPdPdP

इसे ऑनलाइन आज़माएं!


लिया गया (बहुत गोल्फ नहीं) चरम, 145 बाइट्स:

27065671941896667324298575455432398417474802390765222440949482848513*56759961956005660143530475805610581704254588701249011343446231795984498688+P

इसे ऑनलाइन आज़माएं!

यह गणना करता है A*x+B, जहां Aइनपुट चरित्र की स्थिति को Bबताता है और बाकी सभी को इनकोड करता है:

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 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 आदेश बाइट स्ट्रीम के रूप में परिणामी संख्या को प्रिंट करता है।



0

विंडोज बैच, 79 बाइट्स

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

विशेष चार। सुरक्षित, 97 बाइट्स:

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

क्या आप लाइन फीड्स का उपयोग कर सकते हैं.. %1%1%1%1\n %1 %1 %1...
TheLethalCoder

बैच में लाइन फीड का समर्थन नहीं किया जाता है
स्टीवेफेस्टेल

मुझे याद नहीं है कि वे थे या नहीं और परीक्षण करने की स्थिति में नहीं थे :)
TheLethalCoder

क्षमा करें, मैं भ्रमित हूं, क्या आप दोहरा सकते हैं?
स्टेवफेस्टल

मुझे याद नहीं है कि आप उनका उपयोग कर सकते हैं या नहीं और मैं उस समय परीक्षण नहीं कर सकता था जब मैंने टिप्पणी की थी इसलिए मैंने टिप्पणी छोड़ दी ताकि आपको अभी भी विचार हो
TheLethalCoder

0

Tcl, 60 बाइट्स

proc c x {regsub . $x "  &&&&\n & & &\n&&&  &\n& & &\n&&&&"}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.