एंटीफ़ॉर्मोमैग्नेटिक ऑर्डरिंग

16

एंटीफ़ॉर्मोमैग्नेटिक ऑर्डरिंग

एंटीफेरोमैग्नेटिज्म वह है जो आईबीएम के शोधकर्ता 1 टेराबाइट डिस्क से परमाणुओं की समान मात्रा में 100 टेराबाइट डिस्क से कूदते थे ।

ऐसी सामग्रियों में, जो एंटीफेरोमैग्नेटिज्म को प्रदर्शित करती हैं, परमाणुओं या अणुओं के चुंबकीय क्षणों, आमतौर पर इलेक्ट्रॉनों के स्पिन से संबंधित होती हैं, पड़ोसी दिशाओं (विभिन्न उप-नालियों पर) के साथ एक नियमित पैटर्न में विपरीत दिशाओं में इंगित करती हैं।

आपका काम एक प्रोग्राम लिखना है जो ऊपर दिखाए गए चित्र की तरह एंटीफैरोमैग्नेटिक परमाणुओं के क्रम को खींचता है। आपको जोड़े के कम से कम चार सेट करने में सक्षम होना चाहिए, हालांकि आपके पास अधिक हो सकता है।

प्रत्येक जोड़ी को निम्नानुसार दिखाया जाना चाहिए, हालांकि उन्हें वास्तविक तीर होना चाहिए :

 ऊपर नीचे
नीचे ऊपर
 ऊपर नीचे

आपका आउटपुट आस्की आर्ट या ग्राफिकल आउटपुट में हो सकता है।

आप केवल एक फंक्शन या पूरा कार्यक्रम बना सकते हैं, लेकिन इसमें एक इनपुट लेना होगा और कई जोड़ियों को ड्रा करना होगा। केवल शब्दों के उदाहरण :

इनपुट: १

 ऊपर नीचे
नीचे ऊपर
 ऊपर नीचे

इनपुट: २

 ऊपर नीचे होना 
ऊपर नीचे  
 ऊपर नीचे होना

स्वीकार्य तीर:

  • ↑ तथा ↓
  • ⇅ तथा ⇵
  • /|\ तथा \|/

कृपया अपने उत्तर भाषा, एक्स बाइट्स प्रारूप में रखें, क्योंकि यह पढ़ना आसान है। कम से कम बाइट्स जीतता है!

code-golf  ascii-art  graphical-output 
— चरण
स्रोत
5
"कोई भी तीर" मेरे लिए बहुत अस्पष्ट लगता है - किस बारे में ^v?
— Sp3000
1
@ Sp3000 नहीं, क्योंकि उनके पास छोटी पूंछ नहीं है।
— फेज
2
क्या इन तीरों की अनुमति है: ⇅और ⇵? ( यूनिकोड कोड अंक U + 21C5 और U + 21F5 )
— डिजिटल ट्रॉमा
1
@DigitalTrauma वे एकदम सही हैं!
— चरण
11
@ देखें मैंने आपका संपादन वापस कर दिया है। बाइट्स से चरस में स्कोरिंग को बदलने से इनमें से बहुत से जवाबों के लिए स्कोर में काफी बदलाव आएगा। 15 उत्तर मिलने के बाद नियमों को बदलना आम तौर पर गलत होता है।
— डिजिटल ट्रॉमा

जवाबों:

16

एपीएल, 18 12 बाइट्स

⍉(2×⎕)3⍴'↑↓'

यह एक 2n x 3 मैट्रिक्स का निर्माण करता है, जहां n इनपुट ( ⎕) है, वर्णों से भरा है ↑और ↓। ⍉इस मैट्रिक्स का संक्रमण ( ) तब मुद्रित होता है।

आप इसे ऑनलाइन आज़मा सकते हैं ।

— एलेक्स ए।
स्रोत
एपीएल चरित्र सेट का अच्छा दुरुपयोग। मुझे लगता है कि अन्य उत्तर भी इस चरित्र सेट का उपयोग कर सकते हैं, हालांकि।
— jimmy23013
1
@ jimmy23013: APL कोड पेज EBCDIC- आधारित है। यकीन नहीं होता कि कितनी भाषाएं संभाल सकती हैं।
— डेनिस
@ डेनिस ASCII (या EBCDIC में कुछ गिब्रिश) में ही प्रोग्राम नहीं कर सकता, जबकि यह EBCDIC स्ट्रिंग्स प्रिंट करता है? हालांकि, नई सुर्खियों का शॉर्टकट बन जाएगा। वैकल्पिक रूप से, Windows कंसोल के \x18\x19रूप में मुद्रित करने के लिए लग रहा था ↑↓।
— jimmy23013
— jimmy23013
@ jimmy23013: हां, मैंने अभी चैट में पुराने कंसोल के बारे में बात की है । जिबरिश काम कर सकती है, लेकिन यह शायद एक मेटा चर्चा के लायक है।
— डेनिस
12

पायथ, 15 बाइट्स (11 वर्ण)

V3.>*Q"↑↓"N

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

              implicit: Q = input number
V3            for N in [0, 1, 2]:
      "↑↓"       string "↑↓"
    *Q           repeat Q times
  .>      N      rotate the string by N
— Jakube
स्रोत
12

जावा, 313 296 बाइट्स

यहाँ एक उदाहरण दिया गया है जो तीर को ग्राफिक रूप से प्रदर्शित करता है:

import java.awt.*;void f(int n){new Frame(){public void paint(Graphics g){for(int k=0,l,m,o;k<n*6;o=k%6,l=o/2*10+32,m=k/6*20+(k++%2==0?19:29),g.fillPolygon(new int[]{m+4,m,m+4,m+4,m+6,m+6,m+10},o==1|o==2|o==5?new int[]{l+9,l+5,l+5,l,l,l+5,l+5}:new int[]{l,l+5,l+5,l+9,l+9,l+5,l+5},7));}}.show();}

अधिक पठनीय प्रारूप में:

import java.awt.*;
void f(int n) {
    new Frame() {
        public void paint(Graphics g) {
            for (int k = 0, l, m, o; k < n*6;){
                o = k % 6;
                l = o / 2 * 10 + 32;
                m = k / 6 * 20 + (k++ % 2 == 0 ? 19 : 29);
                g.fillPolygon(new int[] {m+4,m,m+4,m+4,m+6,m+6,m+10},
                              o == 1 || o == 2 || o == 5 ?
                                  new int[] {l+9,l+5,l+5,l,l,l+5,l+5} :
                                  new int[] {l,l+5,l+5,l+9,l+9,l+5,l+5},
                              7);
            }
        }
    }.show();
}

इनपुट के रूप में 5 के लिए प्रदर्शन:

5 इनपुट के रूप में प्रदर्शित करें

आपको उस विंडो का आकार बदलना होगा जो तीर को देखने के लिए दिखाई देती है। मैंने इसे बनाने की कोशिश की ताकि उनमें से कोई भी खिड़की के अंदर की सीमा से "कटा हुआ" दिखाई न दे, लेकिन यह कुछ प्लेटफार्मों के लिए इस तरह दिखाई दे सकता है।

— टीएनटी
स्रोत
9

CJam, 18 बाइट्स (14 वर्ण)

ri3*"↑↓"*3/zN*

कॉलम (जो दोहराए जाने वाले पैटर्न बनाते हैं) उत्पन्न करें और फिर स्थानांतरित करें।

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

वैकल्पिक 18 बाइट्स:

3,ri"↑↓"*fm>N*

स्ट्रिंग "↑↓"*nको 0, 1 या 2 बार घुमाएं ।

— Sp3000
स्रोत
7

CJam (15 वर्ण, 19 बाइट्स)

ri"↑↓"*_(+1$]N*

ऑनलाइन डेमो

— पीटर टेलर
स्रोत
1
विन कंडीशन बाइट्स है, न कि चार्ज़।
— ईसैक
@PeterTaylor: चुनौती निर्दिष्ट भाषा, एक्स बाइट्स प्रारूप। आपके पास यह चार प्रारूप में है, लेकिन यूनिकोड वर्ण 2 बाइट के लायक हैं, इसलिए आपका वास्तविक स्कोर 17 बाइट्स है
— लेवी
@Levi के अनुसार इस वे 3 प्रत्येक बाइट्स कर रहे हैं।
— isaacg
@ आइसाकग आह मेरा बुरा
— लेवी
7

Befunge, 71 बाइट्स

मेरा पहला उत्तर, इसलिए कृपया मेरे साथ सौम्य रहें: ओ)

संरेखण के मुद्दों के परिणामस्वरूप कुछ व्यर्थ बाइट्स हुए, अगर आपके पास मेरे लिए कोई सुधार है तो मैं उन्हें सुनना पसंद करूंगा!

&::3>:2% #v_0#v" \|/ "<
  >\^,*52<> 0#v" /|\ "<
:#^_$1-:#^_@  >:#,_$\1-

इनपुट: ४

 /|\  \|/  /|\  \|/  /|\  \|/  /|\  \|/ 
 \|/  /|\  \|/  /|\  \|/  /|\  \|/  /|\ 
 /|\  \|/  /|\  \|/  /|\  \|/  /|\  \|/
— सोक
स्रोत
6

CJam, 14 बाइट्स

0000000: 332c 7269 2218 1922 2a66 6d3e 4e2a       3,ri".."*fm>N*

इसके लिए एक सहायक टर्मिनल की आवश्यकता होती है जो कोड पेज 850 को इस तरह प्रस्तुत करता है :

कोड का गैर-नुकीला भाग @ Sp3000 के वैकल्पिक संस्करण के समान निकला ।

CJam, 17 बाइट्स

ri"⇅⇵⇅"f*N*

Cheaty डबल एरो वर्जन, @DigitalTrauma को क्रेडिट के साथ।

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

— डेनिस
स्रोत
5

पायथ, 16 बाइट्स (12 वर्ण)

J"↑↓"V3*~_JQ

उदाहरण:

Input: 4
Output:
↑↓↑↓↑↓↑↓
↓↑↓↑↓↑↓↑
↑↓↑↓↑↓↑↓
— isaacg
स्रोत
5

पायथन 2, 131 122 बाइट्स

from turtle import*
for k in range(input()*6):z=k/3+k%3&1;pu();goto(k/3*32,z*32^k%3*64);pd();seth(z*180+90);fd(32);stamp()

अच्छा ... मैं सी जावा मुझे लगता है हरा ?

यहाँ छवि विवरण दर्ज करें

मैंने 32तीरों के लिए ऊंचाई चुनी है , जो बहुत बड़ी है, इसलिए थोड़ी देर बाद कछुए ने ऑफ़स्क्रीन ड्राइंग शुरू कर दी। यदि आप बड़े इनपुट के लिए सब कुछ फिट करना चाहते हैं, तो आप या तो 32एस को बदलकर तीर बना सकते हैं , या उपयोग कर सकते हैं screensize()(मुझे यकीन नहीं है कि अगर ऑफ़स्क्रीन आउटपुट पर मेटा पोस्ट है ...)

— Sp3000
स्रोत
1
तो ... जब आप पर्थ में कछुए ग्राफिक्स जोड़ने जा रहे हैं?
— डिजिटल ट्रॉमा
निश्चित रूप से गोल्फ प्रयोजनों के लिए आपको साइज़िंग के लिए एकल अंक संख्या चुननी चाहिए ...
— बीटा डेके
@BetaDecay पूंछ के एकल अंक के लिए मुश्किल से दिखाई देता है, क्योंकि यह कछुए द्वारा अस्पष्ट है
— Sp3000
4

GNU sed, 25 बाइट्स

मुझे ⇅और ⇵यूनिकोड तीर प्रतीक मिले, जो अधिक संक्षिप्त करने की अनुमति देते हैं और उन्हें इस टिप्पणी द्वारा अनुमति दी गई है :

h
s/1/⇅/g
H
G
s/1/⇵/g

इनपुट यूनीरी में है , इसलिए उदाहरण 4 है1111 :

$ echo 1 | sed -f antiferro.sed
⇅
⇵
⇅
$ echo 1111 | sed -f antiferro.sed
⇅⇅⇅⇅
⇵⇵⇵⇵
⇅⇅⇅⇅
$

मामले में पिछला जवाब ⇅ और ⇵अस्वीकृत हैं:

GNU sed, 39 बाइट्स

s/1/↑↓/g
s/.*/&a&↑\n&/
s/a↑/\n/
— डिजिटल आघात
स्रोत
3
जब भी मैं किसी पोस्ट के शीर्ष पर "GNU sed" देखता हूं, तो मुझे यह जानने की भी आवश्यकता नहीं है कि इसे किसने पोस्ट किया है।
— एलेक्स ए।
@AlexA। यह आदमी? ;-)
— डिजिटल ट्रॉमा
इनपुट एकात्मक में है ?! क्या यह भाषा के लिए एक सामान्य चीज है या आपके द्वारा क्रमबद्ध कुछ है?
— बीटा डिके
1
क्या एक नापाक जवाब :-)
— xebtl
1
@BetaDecay ने यूनिक स्ट्रिंग्स की अद्वितीय संपत्ति को अंकित किया है - उनका संख्यात्मक मान उनकी लंबाई के बराबर है। मेटा प्रश्न / उत्तर इसके लिए उन भाषाओं के लिए सख्ती से अनुमति देता है जिनमें देशी अंकगणित (जैसे sed) नहीं है। यह इस प्रश्न के लिए विशेष रूप से आसान है, क्योंकि आवश्यक लंबाई का आउटपुट आसानी से एकरी इनपुट से उत्पन्न किया जा सकता है। Cheaty? शायद - लेकिन मेटा उत्तर सर्वसम्मति इसके साथ ठीक लगता है।
— डिजिटल ट्रामा
3

स्विफ्ट 2, 66 बाइट्स

let f={n in(0..<n*3).map{print("↑↓",appendNewline:$0%n==n-1)}}

यदि स्विफ्ट सिर्फ एक लिटिल बिट कम क्रिया होगी, तो यह भी गोल्फ के लिए बुरा नहीं होगा (मैं आपको देख रहा हूं, नामित पैरामीटर appendNewline)

— Kametrixom
स्रोत
3

रूबी 39 (या 44) अक्षर, 43 (या 48) बाइट्स

इसके अनुसार Https://mothereff.in/byte-counter के तीर के अक्षर 3 बाइट्स हैं!

->(n){a=['↑↓'*n]*3;a[1]=a[1].reverse;a}

एक अनाम फ़ंक्शन जो एक सरणी देता है। यदि फ़ंक्शन को सरणी को प्रिंट करना है, तो इसे समाप्त होना चाहिएputs a 5 और बाइट्स के लिए ।

उदाहरण का उपयोग करें

f=->(n){a=['↑↓'*n]*3;a[1]=a[1].reverse;a}

puts f.call(6)

देता है

↑↓↑↓↑↓↑↓
↓↑↓↑↓↑↓↑
↑↓↑↓↑↓↑↓
— स्तर नदी सेंट
स्रोत
3

जे, ४१ ३५ ३२ बाइट्स (२) अक्षर)

3$(,:|.)(2*".1!:1[1)$ucp'↑↓'

मैंने J में कभी भी कुछ भी प्रोग्राम नहीं किया है इसलिए मुझे इसमें कुछ समय लगा, और यह निश्चित रूप से इसे करने का सबसे अच्छा तरीका नहीं है।

यह आपके लिए एक संख्या का इनपुट करने के लिए प्रतीक्षा करता है जब तीर को आउटपुट करने से पहले चलाया जाता है।

— Fatalize
स्रोत
आपका क्या मतलब है कि आपने जम्मू में कुछ भी प्रोग्राम नहीं किया है? मुझे एक निश्चित J उत्तर याद आ रहा है जो आपको 1k प्रतिनिधि से अधिक मिला। ;)
— एलेक्स ए।
@AlexA। सरल अंकगणित करना वास्तव में वह नहीं है जिसे मैं प्रोग्रामिंग कहूंगा। जब मैंने उस उत्तर को पोस्ट किया तो मुझे वास्तव में J के बारे में बाएं प्राथमिकता के अधिकार के अलावा कुछ भी पता नहीं था
— घातक
2

जावास्क्रिप्ट (ईएस 6), 66 63 53 47 बाइट्स ( 62 55) 49 41 अक्षर)

f=n=>`⇅
⇵
⇅`.replace(/./g,'$&'.repeat(n))

Ps और allowing वर्णों को खोजने और मुझे और बाइट्स से दाढ़ी बनाने की अनुमति देने के लिए डिजिटल ट्रॉमा के लिए सहारा ।

— जॉर्ज रीथ
स्रोत
2

सी, 169 170 162 125 123 105 119 107 बाइट्स

तो, मैं हालांकि मैं यह भी दे सकता हूँ, भले ही यह स्पष्ट रूप से विजेता नहीं है :)

golfed:

n,i,j;main(){n=getchar();n=atoi(&n);for(;j++<3;){for(i=0;i++<n;)printf("%.3s ","⇅⇵"+(j%2)*3);puts("");}}

Ungolfed:

#include <stdio.h>
#include <stdlib.h>

/* n -> Number of columns, i & j -> Loop counters */
n,i,j;

main()
{
    /* Get the number of iterations from stdin */
    n = getchar();
    n = atoi(&n); /* Thanks @AndreaBiondo */

    for (; j++ < 3;)
    {
        /* Print rows of arrows */
        for (i = 0; i++ < n;)
            printf("%.3s ","⇅⇵" + (j % 2) * 3);

        /* Print a newline */
        puts("");
    }
}

उदाहरण:

Input: 4
⇵ ⇵ ⇵ ⇵ 
⇅ ⇅ ⇅ ⇅ 
⇵ ⇵ ⇵ ⇵

अपडेट करें:

इसे यहां देखें

— लेवि
स्रोत
आप कर सकते हैं for(j=0;j++<3;)और उसी के साथi
— lirtosiast
@ThomasKwa अहा ... अच्छी तरह से देखा। धन्यवाद
— लेवी
iऔर jग्लोबल्स हैं, इसलिए वे शून्य से आरंभिक हैं। आप ड्रॉप कर सकते हैं i=0और j=0।
— एंड्रिया बियोन्डो
इसके अलावा, आप nएक बफर के रूप में उपयोग करने के लिए छोटे-धीरज और शून्य आरंभीकरण का फायदा उठा सकते हैं :n=getchar();n=atoi(&n);
— एंड्रिया बियोनडो
@AndreaBiondo जब मैं i = 0 और j = 0 निकालता हूं, तो सभी आउटपुट एक लाइन पर होते हैं। क्या आप इसे पुन: पेश कर सकते हैं? मैं gcc का उपयोग कर रहा हूँ 4.9.2
— लेवी
2

ऑक्टेव, 37 बाइट्स

EDIT: पूर्ववर्ती स्ट्राइप-एंटीफिरोमैग्नेटिक संस्करण से ठीक किया गया। मेरी गलती पकड़ने के लिए धन्यवाद @ बीटा-क्षय।

f=@(n)repmat(["⇅";"⇵";"⇅"],1,n)

एक कार्य को परिभाषित करता है f(n)। नमूना उत्पादन:

octave:4> f(1)
ans =

⇅
⇵
⇅

octave:5> f(5)
ans =

⇅⇅⇅⇅⇅
⇵⇵⇵⇵⇵
⇅⇅⇅⇅⇅
— xebtl
स्रोत
1

CoffeeScript, 60 बाइट्स (58 वर्ण)

पुनरावृत्ति के बिना समझ में यह आसान है:

f=(n,x='')->x+='\n⇵⇅'[i%(n+1)&&1+i%2]for i in[1..n*3+2];x
— rink.attendant.6
स्रोत
1

रूबी, 33 बाइट्स

एक समारोह के रूप में:

f=->n{[s="↑↓"*n,s.reverse,s]}

उदाहरण:

> puts f[3]
↑↓↑↓↑↓
↓↑↓↑↓↑
↑↓↑↓↑↓

रूबी, 37 बाइट्स

पूर्ण कार्यक्रम जो स्टड से इनपुट लेता है:

puts s="↑↓"*gets.to_i,s.reverse,s
— daniero
स्रोत
आप केवल एक फंक्शन या पूरा कार्यक्रम बना सकते हैं, लेकिन इसमें एक इनपुट लेना होगा और कई जोड़ियों को ड्रा करना होगा।
— डेनिस
@ डेनिस ओके, मैं उस पर कायम हूं
— डानिएरो
हमें गलतफहमी होने लगती है। मैंने यह दिखाने के लिए उद्धरण पोस्ट किया कि एक फ़ंक्शन वास्तव में मान्य है, क्योंकि आपने अपने मूल संशोधन में निहित है कि प्रश्न द्वारा एक पूर्ण कार्यक्रम की आवश्यकता थी।
— डेनिस
@ डेनिस कोई समस्या नहीं है। मैं बस सोच रहा था कि 3 स्ट्रिंग्स को वापस करना वास्तव में "ड्राइंग" नहीं था, लेकिन मुझे लगता है कि यह कोई फर्क नहीं पड़ता। वैसे भी, दोनों संस्करणों को थोड़ा नीचे चला गया :)
— daniero
1

> <>, 55 बाइट्स

"⇅⇵⇅"{:&3*1-:0(?;\
|.!09v!?%&:&:{o:}/
oa{~}/|.!09

इसे यहाँ ऑनलाइन आज़माएँप्रारंभिक स्टैक मान के रूप में वांछित लंबाई को इनपुट करते हुए, ।

गैर Non समाधान, 59 बाइट्स:

"↓↑"{:&3*>1-:0(?;{:{\
 |.!09v!?%&:&:oo}}@:/
9oa{$}/|.!0
— Fongoid
स्रोत
1

बीबीसी बेसिक, 70 बाइट्स

INPUTx:n$=STRING$(x,"/|\\|/"):PRINTn$:PRINTSTRING$(x,"\|//|\"):PRINTn$

यह शायद अधिक गोल्फ हो सकता है

— बीटा डिके
स्रोत
1

सी, 97 बाइट्स

पहले कमांड-लाइन पैरामीटर से इनपुट लेता है, जैसे main 4। 357913940जोड़े तक का समर्थन करता है । C में आप मल्टीबाइट कैरेक्टर का उपयोग नहीं कर सकते हैं, charलेकिन वे स्ट्रिंग्स के रूप में ठीक काम करते हैं।

i,n;main(c,v)char**v;{n=atoi(v[1]);for(i=6*n+3;i--;)printf("%s",i%(2*n+1)?i%2?"↓":"↑":"\n");}

यह एक फ़ंक्शन के रूप में छोटा है, लेकिन अन्य सी उत्तर पूर्ण कार्यक्रम थे इसलिए मैंने भी ऐसा किया। यह 69 बाइट्स होगा:

i;f(n){for(i=6*n+3;i--;)printf("%s",i%(2*n+1)?i%2?"↓":"↑":"\n");}
— एंड्रिया बियोन्डो
स्रोत
1

सी, 117 89 85 85 बाइट्स

i;main(j,v)char**v;{j=2*atol(v[1])+1;for(;i++<3*j;)printf(i%j?i%2?"↑":"↓":"\n");}

Ungolfed:

i;
main(j,v)
char**v; // Credit to @AndreaBiondo for brilliant idea that I will use a lot in future golfed programs :)
{
    j = 2*atol(v[1])+1;
    for(;i++<3*j;)
        printf(i%j?i%2?"↑":"↓":"\n");
}
— कोल कैमरन
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स (62 वर्ण)

इसमें यूनिकोड वर्ण को तीन बाइट्स के रूप में गिना जाता है और साथ ही एक बाइट के रूप में गिने जाने वाले अनिवार्य न्यूलाइन को भी शामिल किया जाता है।

इस उत्तर से प्रेरित होकर पुनरावृत्ति का उपयोग करता है । मैंने इसे गैर-पुनरावर्ती रूप से आज़माया, लेकिन एक परिभाषित सरणी पैदा करने में बहुत सारे अक्षर लगे, हालांकि किसी और को यह पता चल सकता है कि यह मुझसे बेहतर कैसे कर सकता है।

f=n=>(g=(a,i)=>i?g(`
↓↑`[i%(n*2+1)&&1+i%2]+a,i-1):a)('',n*6+2)

डेमो

सभी ईएस 6 उत्तरों के साथ, वे फ़ायरफ़ॉक्स, एज और सफारी 9 में केवल लेखन के समय ही प्रदर्शित होते हैं:

f = n => (g = (a, i) => i ? g(`
↓↑` [i % (n * 2 + 1) && 1 + i % 2] + a, i - 1) : a)('', n * 6 + 2)

console.log = x => document.getElementById('O').innerHTML += x + '\n';

console.log(f(1));
console.log(f(2));
console.log(f(4));
console.log(f(32));
<pre><output id=O></output></pre>
स्निपेट का विस्तार करें

— rink.attendant.6
स्रोत
1

जावा, 150 बाइट्स

static void g(int n){n*=2;f(n,0);f(n,1);f(n,0);}static void f(int n,int d){String l="";for(n+=d;n-->d;)l+=(n%2==0)?"↓":"↑";System.out.println(l);}

का आउटपुट g(2):

↑↓↑↓
↓↑↓↑
↑↓↑↓
— DeadChex
स्रोत
1
मुझे लगता है कि आपको तीर का उत्पादन करने की आवश्यकता है, इसलिए मैं सुझाव दूंगा कि आप अपना उदाहरण आउटपुट और कोड बदलें ताकि यह स्पष्ट हो सके कि आप नियम नहीं तोड़ रहे हैं :)
— बीटा डेके
@BetaDecay मुझे लगता है कि कुछ स्वीकृत तीर सूचीबद्ध किए गए हैं और मैंने कटौती नहीं की है! तो आपकी सलाह के बाद मैंने इसे बदल दिया है
— DeadChex
0

पायथन 2, 45 55 बाइट्स

संपादित करें: संशोधित तीर

बहुत सीधा-सादा तरीका। हालांकि यूनिकोड तीर के साथ काम नहीं करता है।

def f(n):x=" /|\\ \\|/"*n;print x+"\n "+x[::-1]+"\n"+x
— Heo
स्रोत
यदि आप मूल पोस्ट में टिप्पणियों को देखते हैं, तो आप देखेंगे कि आपको विशेष^v रूप से तीर का उपयोग करने की अनुमति नहीं है क्योंकि उनके पास एक पूंछ नहीं है
— लेवी
1
धन्यवाद, मैंने उस पर ध्यान नहीं दिया। इसे "/ | \" में बदल दिया, आशा है कि यह अब ठीक है।
— Heo
0

आर, 60 62 बाइट्स

STDIN से इनपुट लेता है और STDOUT को आउटपुट देता है। एक 3 x (2 * इनपुट) सरणी बनाता है , गाड़ी के रिटर्न का एक कॉलम जोड़ता है और फिर ट्रांसपोज़्ड सरणी को आउटपुट करता है।

cat(t(cbind(array(c('↑','↓'),c(3,2*scan())),'\n')),sep='')

परीक्षण चालन

cat(t(cbind(array(c('↑','↓'),c(3,2*scan())),'\n')),sep='')
1: 25
2: 
Read 1 item
↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓
↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑
↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓↑↓
— MickyT
स्रोत
0

Tcl 49 बाइट्स

कोई विजेता नहीं लेकिन कम से कम यह प्रतिस्पर्धी है:

foreach x {⇅ ⇵ ⇅} {puts [string repeat $x $argv]}
— slebetman
स्रोत
आप lmapforeach
— सर्जियोल
और string repeatसंक्षिप्त किया जा सकता हैstring re
— नाग
और मुझे यकीन नहीं है, लेकिन इसके procसाइड इफेक्ट को पुनः प्राप्त करने के रूप में लागू कर रहा हूंlmap वाले मूल्यों के और $argvकिसी एक-पत्र चर द्वारा प्रतिस्थापित करके बाइट्स बचा सकता है।
— सर्गियोल
-1

स्विफ्ट 2.0, 79 बाइट्स

कुछ भी चालाक नहीं है ...

let p=3;for x in 0...2{print((0..<p*2).reduce(""){$0+["↑","↓"][($1+x)%2]})}
— GoatInTheMachine
स्रोत
3
इसे एक फंक्शन में रखना होगा, इनपुट के लिए कोड बदलने की अनुमति नहीं है
— डाउगोलेट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.