मेरी आखिरी चुनौती, इससे पहले कि मैं ब्रेक पर जाऊं ।
सकारात्मक पूर्णांक को देखते हुए n, यदि nविषम है , तो /कई बार दोहराएं ; यदि nहै, तो भी \कई बार दोहराएं ।
(गंभीरता से, वृषण इस विवरण की तुलना में बहुत स्पष्ट होगा, इसलिए केवल वृषण को देखें।)
n output
1 /
2 \\
3 ///
4 \\\\
5 /////
6 \\\\\\
जवाबों:
n=>"\\/"[n%2].repeat(n)
एक अनाम फ़ंक्शन को परिभाषित करता है।
यदि केवल *जावास्क्रिप्ट में बार-बार तार। सांस लेते हुए
f=n=>...सीधे इसे कॉल कर सकते हैं (n=>...)(5):। (या यदि आप Node.js REPL का उपयोग कर रहे हैं, तो आप उपयोग कर सकते हैं this._, जो अंतिम चीज़ में प्रवेश के लिए खड़ा है)
के लिए +1 शामिल है -p
STDIN पर इनपुट के साथ चलाएँ:
squigly.pl <<< 6
squigly.pl
#!/usr/bin/perl -p
$_=$_%2x$_;y;01;\\/
-pविकल्प का उपयोग कर रहे हैं ? मैं ;बिल्कुल ट्रांसपेरेंट में उपयोग करता हूं क्योंकि कोड के अंत -pमें एक निहित है ;इसलिए मैं 1 और बाइट बचा सकता हूं। यह कम से कम पर्ल 5.6 के बाद से काम कर रहा है (शायद जब तक -pविकल्प वास्तव में मौजूद था)
;जोड़ा के साथ कि चाल -pकाफी अच्छा है, अच्छी तरह से किया है।
.+
$*/
T`/`\\`^(..)+$
इसे ऑनलाइन आज़माएं (पहली पंक्ति को कई टेस्टकेस चलाने की अनुमति देने के लिए जोड़ा गया है)।
putchar(92-n%2*45)एक ही लंबाई है।
ị⁾/\x
इसे ऑनलाइन आज़माएं! या सभी टेस्टकेस सत्यापित करें।
ị⁾/\x
ị⁾/\ modular-indexing into the string "/\"
x repeat
Ø^यह बाइट से कम है ⁾/\ ।
#'\/'{~2|]
यह एक छह-ट्रेन क्रिया है, जिसमें निम्न शामिल हैं:
# ('\/' {~ 2 | ])
यह एक हुक है #और ('\/' {~ 2 | ]); एक हुक का (f g) yविस्तार होता है y f (g y), इसलिए यह विस्तार करता है y # (... y), जो एकल-वर्णों के लिए, वर्णों की एक सूची देता है y।
दूसरा भाग 5-ट्रेन है, जिसमें शामिल हैं:
'\/' {~ 2 | ]
यह दो कांटे का मूल्यांकन करता है:
'\/' {~ (2 | ])
आंतरिक कांटा, 2 | ]मापांक दो है। बाहरी कांटा, इसलिए है:
'\/' {~ mod2
जो स्ट्रिंग से {~mod2 इंडेक्स ( mod2) लेता है /।
फिर, ऊपर से हुक का उपयोग करना:
y # (apt char)
इससे हमें जो चाहिए, वह मिलता है और हम काम करते हैं।
If[OddQ@#,"/","\\"]~Table~#&
अनाम फ़ंक्शन। एक पूर्णांक को इनपुट के रूप में लेता है और आउटपुट के रूप में वर्णों की सूची देता है।
~Table~#।
<>""पात्रों को सूचीबद्ध कर सकते हैं ।
~Do~Infinityऔर 10.2+ में भी जोड़ा होगा ...
अद्यतन करें:
param($n)('\','/')[$n%2]*$n
करने के लिए स्विचन param, टाइममेड के लिए धन्यवाद ।
"$("\/"[$args[0]%2])"*$args[0]
या थोड़ा अधिक पठनीय
("\","/")[$args[0]%2]*$args[0]
परीक्षा:
> 1..10 | % { ./run.ps1 $_ }
/
\\
///
\\\\
/////
\\\\\\
///////
\\\\\\\\
/////////
\\\\\\\\\\
param($n)हैं $args, जैसे कि 27 बाइट्स के लिए निम्नानुसार इनपुट करें -param($n)('\','/')[$n%2]*$n
"\\"["/"][[#~Mod~2]]~Table~#&
क्रूली इस तथ्य का फायदा उठाता है कि [[1]]फ़ंक्शन का पहला तर्क [[0]]देता है जबकि फ़ंक्शन (हेड) को खुद लौटाता है, जिसे अजीब तरह से मान्य फ़ंक्शन पर लागू किया जाता है जिसका नाम "\\""मूल्यांकन" किया जा रहा है "/"।
a[b]का कुछ केवल सिर (इंडेक्स ) और तत्व (इंडेक्स ) के साथ एक सामान्य अभिव्यक्ति है , और फ़ंक्शन केवल विशेष प्रकार के अभिव्यक्ति हैं (वास्तव में, यह कहना अधिक सही होगा कि फ़ंक्शन उत्पन्न होते हैं ' टी एक्सप्रेशंस, लेकिन केवल एक्सप्रेशन बदलने के नियम हैं जो आमतौर पर फॉर्म होते हैं )। :)a0b1f[x...]
:2%:"\/"rm:?jbw
:2% Input mod 2…
:"\/"rm …is the index of the element in string "\/",…
:?j …element that we juxtapose Input times to itself…
bw …and print to STDOUT after removing one slash/backslash
ri_"\/"=*
ri e# Read input and convert to integer N.
_ e# Duplicate N.
"\/"= e# Use N as cyclic index into "\/", giving '\ for even and '/ for odd inputs.
* e# Repeat N times.
:2%?'/'o1-:?!;30.
30. >'\'50p
पहली बार इस भाषा का उपयोग करते हुए, लेकिन मुझे लगता है कि मैंने कम से कम / या तो आउटपुट या दर्पण के पुनर्निर्देशित प्रवाह के हिस्से के रूप में सशर्त रूप से उपयोग करके थोड़ा कमरा बचा लिया। शायद अभी भी बहुत ही अक्षम है, हालांकि, मुझे लगता है कि यह शायद बहुत कम से कम थोड़ा नीचे काटा जा सकता है।
इनपुट प्रारंभिक स्टैक है, आउटपुट है stdout
⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की
आवश्यकता होती है।
⊢⍴'\/'⊃⍨2|⊢⊢ बहस
⍴ फेरबदल (दोहराव)
'\/'⊃⍨ स्ट्रिंग "/" द्वारा चयनित
2|⊢ जब तर्क दो से विभाजित होता है तो विभाजन शेष रहता है
void c(int i){for(int x=0;x++<i;)System.out.print(i%2<1?92:'/');}
3 बाइट्स के लिए धन्यवाद बचाया @ user902383 और @SeanBean ।
वैसे ही जैसे इस जवाब के साथ , कम से कम कोड गोल्फ पाश और प्रिंट करने लगता है। दोनों पुनरावर्ती और
void c(int i){System.out.print(new String(new char[i]).replace("\0",i%2<1?"\\":"/"));}
लंबे समय तक प्रतीत होते हैं।
Ungolfed और परीक्षण कोड:
class M{
static void c(int i){
for(int x = 0; x++ < i;){
System.out.print(i % 2 < 1
? 92
: '/');
}
}
public static void main(String[] a){
for(int i = 0; i < 10; i++){
c(i);
System.out.println();
}
}
}
आउटपुट:
/
\\
///
\\\\
/////
\\\\\\
///////
\\\\\\\\
/////////
x=-1;++x<iजाते x=0;x++<iहैं तो आप एक बाइट को कम कर सकते हैं
"\\" : "/"के साथ 92:'/');
n=scan();cat(rep(c("\\","/")[n%%2+1],n),sep="")
आर में, आपको बैकस्लैश से बचना होगा। तर्क sepभी पूरी तरह से निर्दिष्ट किया जाना चाहिए क्योंकि यह बाद में आता है ...। इस प्रकार कष्टप्रद कुछ अवसरों को बचाने के लिए :(
एक बाइट दूर गोल्फिंग के लिए बाउंसीबॉल के लिए धन्यवाद।
n=scan();cat(rep(c('\\','/')[n%%2+1],n),sep='')
"\/"@aXa
सीधा। इसे गुणा करने के लिए चरित्र और स्ट्रिंग पुनरावृत्ति का चयन करने के लिए मॉड्यूलर अनुक्रमण का उपयोग करता है। इसे ऑनलाइन आज़माएं!
यह सवाल पिप, पाइथ और जैली के बीच एक दिलचस्प तुलना प्रस्तुत करता है , बाद वाले दो ने प्रत्येक को 5 बाइट दिए। मॉड्यूलर अनुक्रमण और स्ट्रिंग पुनरावृत्ति के लिए सिंगल-चार ऑपरेटरों के साथ सभी तीन भाषाओं में निहित आउटपुट हैं, और स्ट्रिंग में बैकस्लैश से बचने की कोई आवश्यकता नहीं है। हालांकि दो प्रमुख अंतर हैं:
न तो इन विशेषताओं में से एक को पिप 1 में दिखाने की संभावना है (मैं असंतुलित सीमांकक के सौंदर्यशास्त्र को पसंद नहीं करता हूं, और बिंदु-मुक्त सिंटैक्स या अंतर्निहित ऑपरेशंस ऐसा लगता है जैसे वे मेरे इन्फिक्स एक्सप्रेशन पार्सर के लिए बहुत भिन्न होंगे), लेकिन मैं ' तीसरा फिडेल खेलने के साथ ठीक है। भले ही "पठनीयता" गोल्फिंग के सापेक्ष बहुत अधिक है, मैं यह तर्क दूंगा कि उन तीन अतिरिक्त बाइट्स ने पिप प्रोग्राम को एक नज़र में समझना बहुत आसान बना दिया है - और मेरी पुस्तक में, यह एक सार्थक ट्रेडऑफ़ है।
1 हालांकि, पिप में एकल-वर्ण स्ट्रिंग्स 'सीजम से प्रेरित और लिस्प में उद्धृत करके एक एकल सीमांकक का उपयोग करते हैं।
code golf! = golflang design। अब आप अच्छी तरह से तर्क दे सकते हैं कि यही सिद्धांत (हमेशा बेहतर होता है) भाषा के डिजाइन पर भी लागू होता है। मैं सिर्फ कह रहा है कि मेरे लिए, प्रयोज्य और यहां तक कि सौंदर्यशास्त्र हैं विचार।
{<\ />[$_%2]x$_}for 1..6 {
say $_, {<\ />[$_%2]x$_}( $_ )
}1/
2\\
3///
4\\\\
5/////
6\\\\\\!x="$("/\\"[x%2])"^x
(i,j)->{for(j=i;j-->0;)System.out.print(i%2<1?92:'/');};
मैं अपने जवाब को आगे बढ़ाने के लिए @Kevin क्रूज़सेन को धन्यवाद देना चाहता हूं।
public static void main(String[] args) {
BiConsumer<Integer, Integer> consumer = (i, j) -> {
for (j = i; j-- > 0;) {
System.out.print(i % 2 < 1 ? 92 : '/');
}
};
consumer.accept(5, 0);
consumer.accept(1, 0);
consumer.accept(8, 0);
}
गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!
;'\'/2(%I*
यह काम किस प्रकार करता है
Implicit input of n
; Duplicate n
'\'/ The strings "/" and "\"
2(% n mod 2
I If n mod 2, then "/", else "\"
* Multiply by n. Implicit print at the end.