46

इस चुनौती में नकली मार्की टेक्स्ट वह पाठ होता है जिसे स्क्रॉलिंग जैसे फैशन में भाग द्वारा दिखाया जाता है।

कुछ उदाहरण:

testing 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g


hello 2

 h
he
el
ll
lo
o


foobarz 3

  f
 fo
foo
oob
oba
bar
arz
rz
z


Something a bit longer 10

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer
t longer
 longer
longer
onger
nger
ger
er
r


small 15

              s
             sm
            sma
           smal
          small
         small
        small
       small
      small
     small
    small
   small
  small
 small
small
mall
all
ll
l


aaa 3

  a
 aa
aaa
aa
a


brace yourself 6

     b
    br
   bra
  brac
 brace
brace 
race y
ace yo
ce you
e your
 yours
yourse
oursel
urself
rself
self
elf
lf
f

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

यदि आपका प्रोग्राम स्टैंडअलोन है (अर्थात जब रन वास्तव में लाइनों को प्रिंट करता है) (इनपुट को हार्ड-कोडित लेकिन बदलने में आसान हो सकता है) और आउटपुट की प्रत्येक पंक्ति के बीच थोड़ा सा सोता है जो आपको -10 बोनस मिलता है।

code-golf string

— Caridorc
स्रोत

"आउटपुट शामिल है" से आपका क्या तात्पर्य है?

— ऑप्टिमाइज़र

1

इसके अलावा, क्या हमें पहली और आखिरी पंक्तियों को प्रिंट करना है जो कि केवल रिक्त स्थान हैं?

— ऑप्टिमाइज़र

2

से प्रेरित होकर इस ?

— स्पिकैट्रिक्स

1

शुरुआत में एक खाली लाइन की अनुमति दी जाती है। अंत में एक और खाली लाइन के बारे में कैसे?

— नीमी

2

चूंकि आप "केवल दृश्यमान आउटपुट" के बारे में बात कर रहे हैं, क्या हम मान सकते हैं कि इनपुट केवल मुद्रण योग्य ASCII होगा? (चरित्र कोड 0x20 से 0x7E)

— मार्टिन एंडर

24

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

1 बाइट डेनिस ने बचाया।

,Sf*\f+$zN*

मैं "इनपुट हार्ड-कोडेड लेकिन बदलने में आसान हो सकता है" का उपयोग कर रहा हूं: यह इनपुट को स्टैक पर पहले से ही होने की उम्मीद करता है, इसलिए आप "testing" 4उदाहरण के लिए, ऊपर दिखा सकते हैं ।

इसका परीक्षण यहां करें।

व्याख्या

ध्यान दें कि वांछित आउटपुट का संक्रमण बहुत सरल है:

   testing
  testing
 testing
testing

इसलिए हमें बस बनाने की जरूरत है n नीचे से नीचे तक के iलिए जगह , लाइनों है । यही कोड करता है:in-10

,            e# Turn n into a range [0 1 .. n-1]
 Sf*         e# Turn each i into a string of i spaces.
    \f+      e# Swap this array with the input string and append it to each of the
             e# strings of spaces.
       $     e# Sort the array to have the string with n-1 spaces first.
        z    e# Transpose the grid.
         N*  e# Join the lines with newline characters.

19 - 10 = 9?

मुझे लगता है कि "प्रत्येक पंक्ति के बीच एक बिट सोता है" बोनस थोड़ा अस्पष्ट और नीरस है, लेकिन यहां एक 19 बाइट संस्करण है जो कि सरणी के सभी क्रमों की गणना करके प्रत्येक पंक्ति के बाद बस स्टॉल करता है [0 1 .. 7]। ऑनलाइन दुभाषिया में यह बस अंतिम परिणाम की ओर जाता है, बाद में थोड़ा दिखाया जाता है, लेकिन यदि आप जावा दुभाषिया का उपयोग करते हैं, तो यह वास्तव में "थोड़ी नींद" के बाद प्रत्येक पंक्ति को प्रिंट करेगा:

,Sf*\f+$z{oNo8e!;}/

— मार्टिन एंडर
स्रोत

का अच्छा उपयोग z। इनपुट मान लिया जाये कि प्रिंट योग्य ASCII, आप की जगह ले सकता है W%के साथ $।

— डेनिस

@ डेनिस ओह, मुझे वह पसंद है। मैंने ओपी से इस पर स्पष्टीकरण मांगा है। (कहा कि, मैं zहर समय एएससीआई ग्रिड-आधारित चुनौतियों के लिए उपयोग करता हूं ।)

— मार्टिन एंडर

15

सी, 69 बाइट्स

प्रिंटफ मैजिक!

f(s,n,i)char*s;{for(i=n;*s;i?i--:s++)printf("%*s%.*s\n",i,"",n-i,s);}

कुछ स्पष्टीकरण के साथ विस्तारित संस्करण:

f(s,n,i)char*s;{       /* s is the string, n is the width of the grid. */
  for(i=n;             /* i is the number of preceding spaces. */
      *s;              /* Stop once we reach the end of the string. */
      i?i--:s++)       /* Decrease the number of spaces, and when there's 
                          none left start truncating the string itself. */
  printf("%*s          /* The first argument is the minimum width to print the 
                          string (left padded with spaces) and the second 
                          argument is the string to print. We use the empty 
                          string just to print the i spaces. */
    %.*s              /* The third argument is the maximum number of 
                         characters from the string (which is the fourth 
                         argument) to print. */
    \n",i,"",n-i,s);
}

और यहाँ एक उदाहरण है:

$ ./marquee स्टैकओवरफ़्लो 12

           रों
          सेंट
         स्टेशन
        Stac
       ढेर
      stacko
     stackov
    stackove
   stackover
  stackoverf
 stackoverfl
stackoverflo
tackoverflow
ackoverflow
ckoverflow
koverflow
बाढ़
verflow
erflow
rflow
बहे
कम
ओउ
w

— Cl-
स्रोत

14

पायथ, 13 बाइट्स

jb.:++K*dQzKQ

इसे ऑनलाइन आज़माएं: पायथ कंपाइलर / एक्ज़ीक्यूटर

व्याख्या

                 implicit: z = input string, Q = input number
      K*dQ       K = " " * Q
    ++K   zK     K + z + K
  .:        Q    all substrings of length Q
jb               join by newlines and print

— Jakube
स्रोत

6

पायथन 65 63

s=lambda t,s:'\n'.join((' '*s+t)[i:s+i]for i in range(len(t)+s))

यह वास्तव में उदाहरण लिखने के लिए इस्तेमाल किया गया था। बेसलाइन समाधान।

>>> print(s("foobarz", 3))

  f
 fo
foo
oob
oba
bar
arz
rz
z

— Caridorc
स्रोत

2

मैं इसे परीक्षण नहीं किया है, लेकिन आप के अंदर वर्ग कोष्ठक को दूर करने में सक्षम होना चाहिएjoin

— undergroundmonorail

@undergroundmonorail राइट

— कारिडोर

6

जावास्क्रिप्ट ( ईएस 7 ड्राफ्ट ), 61 बाइट्स

f=(s,l)=>[x.substr(i,l)for(i in x=' '.repeat(l)+s)].join(`
`)

<input id="str" value="Some String" />
<input id="num" value="5" />
<button onclick="out.innerHTML=f(str.value, +num.value)">Run</button>
<br /><pre id="out"></pre>

स्निपेट का विस्तार करें

जावास्क्रिप्ट ( ES6 ) हार्डकोड इनपुट, 47 बाइट्स

चर s(स्ट्रिंग) और l(लंबाई) में हार्ड-कोडित इनपुट्स को मानते हुए , इसे प्रत्येक पंक्ति के लिए अलर्ट के साथ 47 बाइट्स प्रिंटिंग के लिए कम किया जा सकता है :

for(i in x=' '.repeat(l)+s)alert(x.substr(i,l))

— nderscore
स्रोत

5

के, 19 बाइट्स

{x#'![1]\(x#" "),y}

कील xरिक्त स्थान ( x#" ") स्ट्रिंग की शुरुआत पर y। फिर \घुमाए गए तारों के सेट को बनाने के लिए ऑपरेटर के "फिक्स्ड-पॉइंट स्कैन" फॉर्म का उपयोग करें। यदि फ़ंक्शन को लागू करने का परिणाम दोहराया परिणाम देता है या यदि प्रारंभिक इनपुट पुनरीक्षित होता है, तो कश्मीर में एक निश्चित-बिंदु इसे चलना बंद कर देता है। चूँकि ![1]एक समय में एक स्ट्रिंग को एक कदम घुमाएगा, ![1]\चक्रीय क्रमपरिवर्तन के लिए एक अच्छा मुहावरा है। फिर हम केवल परिणामों को ट्रिम करते हैं x#'।

एक नमूना रन:

  {x#'![1]\(x#" "),y}[4;"some text"]
("    "
 "   s"
 "  so"
 " som"
 "some"
 "ome "
 "me t"
 "e te"
 " tex"
 "text"
 "ext "
 "xt  "
 "t   ")

— JohnE
स्रोत

5

जे (22)

यह मेरे अनुमान से अधिक लंबा हो गया, लेकिन मुझे लगता है कि यह बहुत बुरा नहीं है।

[{."0 1[:]\.(' '#~[),]

मजेदार तथ्य: गैर से [और ]वास्तव में मेल खाते हैं, या एक दूसरे के साथ कुछ भी करना है।

— ɐɔıʇǝɥʇuʎs
स्रोत

3 छोटे बदलावों के बाद: [{."1]]\.@,~' '#~[(18 बाइट्स)।

— यादृच्छिक

5

जूलिया, 75 बाइट्स

(s,n)->(n-=1;print(join([(" "^n*s*" "^n)[i:n+i]for i=1:length(s)+n],"\n")))

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग और पूर्णांक को इनपुट के रूप में स्वीकार करता है और आउटपुट प्रिंट करता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=(s,n)->(...)।

असंगठित + स्पष्टीकरण:

function f(s, n)
    # Decrement n by 1
    n -= 1

    # Construct the lines as an array using comprehension by repeatedly
    # extracting subsets of the input string padded with spaces
    lines = [(" "^n * s * " "^n)[i:n+i] for i = 1:length(s)+n]

    # Print the array elements separated by a newline
    print(join(lines, "\n"))
end

उदाहरण:

julia> f("banana", 3)
  b
 ba
ban
ana
nan
ana
na 
a

julia> f("Julia", 6)
     J
    Ju
   Jul
  Juli
 Julia
Julia 
ulia  
lia   
ia    
a

ध्यान दें कि यदि यह समाधान 66 बाइट्स का है sऔर nमाना जाता है कि यह कार्यक्रम में पहले से मौजूद है।

— एलेक्स ए।
स्रोत

5

QBasic, 56 - 10 = 46

यह QBasic गोल्फ है - ऑटोफॉर्माटर ?में विस्तार करेगा PRINTऔर कुछ रिक्त स्थान जोड़ेगा। के साथ परीक्षण किया गयाQB64 के गया , हालाँकि यहाँ कुछ भी नहीं होना चाहिए जो DOS QBasic के साथ काम नहीं करेगा।

s=SPACE$(n)+s
FOR i=1TO LEN(s)
?MID$(s,i,n)
SLEEP 1
NEXT

QBasic आम तौर पर स्ट्रिंग ऑपरेशन के साथ अच्छा नहीं है, लेकिन बहुत आसानी से एक फ़ंक्शन है जो दिए गए स्थानों की संख्या देता है!

"इनपुट हार्ड-कोड किया जा सकता है" के साथ कुछ स्वतंत्रताएं लेते हुए, यह कोड वेरिएबल sके DIM'डी' होने की उम्मीद करता है AS STRING, ताकि $टाइप प्रत्यय से बचा जा सके , साथ ही साथ स्ट्रिंग को सौंपा जा रहा है।s और नंबर को सके n।

उदाहरण प्रस्तावना:

DIM s AS STRING
s="string"
n=4

आउटपुट:

   रों
  सेंट
 str
stri
trin
अंगूठी
आईएनजी
एनजी
जी

शीर्ष रिक्त पंक्ति को FOR1 के बजाय 2 पर लूप शुरू करके समाप्त किया जा सकता है ।

बोनस: एक पलटे चार बाइट्स के लिए CLSसही जोड़ने से पहले NEXTयह बदल जाता है ... एक असली मार्की !

मार्की

मैं PRINT CHR$(3)QBasic। : ^ डी

— DLosc
स्रोत

मुझे फिर से QBasic की कोशिश करनी चाहिए ... यह वही है जो मैंने पहली बार सीखा है

— कनाडाई ल्यूक पुनर्जीवित मेना

5

रूबी, 68 , 55 बाइट्स

a=" "*$*[1].to_i+$*[0]+" ";a.size.times{|b|puts a[b...b+$*[1].to_i]}

@Blutorange से अपडेट के बाद:

a=" "*(z=$*[1].to_i)+$*[0];a.size.times{|b|puts a[b,z]}

आउटपुट:

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer 
t longer 
 longer 
longer 
onger 
nger 
ger 
er 
r

ruby marquee.rb "Something a bit longer" 10

पहली बार तो आलोचना के लिए प्रस्तुत।

— DickieBoy
स्रोत

1

कुछ रूबी शॉर्टकट्स का उपयोग करते हुए, मुझे अच्छा लग रहा है। अंतिम स्थान हालांकि ("केवल दृश्यमान आउटपुट मायने रखता है") a=" "*(z=$*[1].to_i)+$*[0];a.size.times{|b|puts a[b,z]}

— परिगलित

@blutorange प्रतिक्रिया के लिए धन्यवाद!

— डिकिएबॉय

आपका स्वागत है। यदि आप चाहें तो उत्तर को संपादित करने के लिए स्वतंत्र महसूस करें;)

— blutorange

4

हास्केल, 61 59 54 बाइट्स

m n=unlines.scanr((take n.).(:))[].(replicate n ' '++)

उपयोग उदाहरण:

*Main> putStr $ m 6 "stackoverflow"

     s
    st
   sta
  stac
 stack
stacko
tackov
ackove
ckover
koverf
overfl
verflo
erflow
rflow
flow
low
ow
w

*Main>

संपादित करें: शुरुआत / अंत में एक खाली लाइन की अनुमति है

— nimi
स्रोत

4

बैश, 109 - 10 = 99 बाइट्स

मैं देख रहा हूं कि जिस समय मुझे अपना समाधान लिखने में समय लगा, तब मुझे बुरी तरह से पीटा गया। फिर भी, मैंने इसे पोस्ट न करने के लिए इसे लिखने में बहुत लंबा समय लगाया ...

इसके अलावा, इसकी कुछ अनूठी विशेषताएं हैं, जैसे कि वर्तमान निर्देशिका में कितना है, इसके आधार पर उपयोगकर्ता-समायोज्य मुद्रण लाइनों के बीच का समय! (यह भी कुछ असंगत है, यह निर्भर करता है कि आपकी डिस्क कैसी है)

l=${#1};s=$1;for j in `seq 1 $2`;do s=" $s";done;for i in `seq 0 $((l+$2))`;do echo "${s:i:$2}";find 1>2;done

उदाहरण:

cd <some directory in which you own everything recursively>
Marquee.sh "Test Case" 4

   T
  Te
 Tes
Test
est 
st C
t Ca
 Cas
Case
ase
se
e

असंबद्ध और टिप्पणी:

l=${#1} #Length of the incoming string
s=$1 #Can't reassign to the parameter variables, so give it another name
for j in `seq 1 $2`; do
    s=" $s" # Put on the padding spaces
done

for i in `seq 0 $((l+$2))`; do
    #Cut the string and print it. I wish I could lose "padding" that easily!
    echo "${s:i:$2}" #Format is ${string:index:length}, so always the same
    # length, with the index moving into the string as the loop advances
    find 1>2  #Wait "a bit". From ~/, about 6 minutes per line on my junky 
    # computer with a huge home directory. Probably in the <1 sec range for
    # most people.
    #This actually has the same character count as sleep(X), but is much
    # more fun!
done

मैंने पहले कभी ऐसा नहीं किया। सुझाव और टिप्पणियों का स्वागत है!

— Sompom
स्रोत

4

शुद्ध बैश, 61 बाइट्स

printf -vs %$2s"$1"
for((;++i<${#1}+$2;)){
echo "${s:i:$2}"
}

आउटपुट:

$ ./marquee.sh testing 4
   t
  te
 tes
test
esti
stin
ting
ing
ng
g
$

— डिजिटल आघात
स्रोत

मुझे लगता है कि मैं "शुद्ध" बैश के अंतर को नहीं समझता, इसलिए शायद यह सुझाव कोई अच्छा नहीं है, लेकिन नींद (1) 8 अक्षर है और आपको -10 देता है (और जीएनयू कोर

— यूटिल है

3

पर्ल, 50

$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)

57पात्रों +3के लिए -i, -nऔर -l। -10नींद के लिए वर्ण।

-iसंख्यात्मक इनपुट के लिए उपयोग किया जाता है, जो इसमें संग्रहीत होता है $^I। मूल रूप से, हम iइनपुट के सामने और अंत में रिक्त स्थान जोड़ते हैं , और फिर iउनके साथ प्रत्येक वर्ण और लूप की खोज करते हैं while। sayसुविधाजनक रिटर्न 1जो हम इनपुट कर सकते हैं sleep।

echo "testing" | perl -i4 -nlE'$c=$" x$^I;$_="$c$_$c";sleep say$1while(/(?<=(.{$^I}))/g)'

— hmatt1
स्रोत

मुझे पता है कि यह पुराना है, लेकिन यह सिर्फ फ्रंट पेज पर वापस कूद गया है और मुझे कुछ हद तक सिकुड़ गया है s/^|$/$"x$^I/eg;sleep say$1 while s/.(.{$^I})/$1/:। आप -lध्वज को भी खो सकते हैं , लेकिन मुझे लगता है कि यदि आप के माध्यम से चलाते हैं, तो आपको 5 की गणना करने की आवश्यकता है -i -n(क्योंकि -iडिफ़ॉल्ट ध्वज नहीं है) echo -n "testing" | perl -i4 -nE'...'। हालांकि अभी भी 44 से नीचे होना चाहिए!

— डोम हेस्टिंग्स

@DomHastings धन्यवाद डोम! अच्छा काम, मैं बाद में अपना जवाब संपादित करूँगा :)

— hmatt1 15

3

POSIX खोल, 94

[ $3 ]||set "`printf "%${2}s"`$1" $2 t
[ "$1" ]&&printf "%-.${2}s" "$1" "
"&&$0 "${1#?}" $2 t

मुझे पता है कि यह पर्ल के करीब लग रहा है, लेकिन यह वास्तव में शेल है!

पहली पंक्ति लूप के माध्यम से केवल पहली बार आवश्यक अग्रणी स्थान जोड़ती है। यह इंगित करने के लिए $ 3 सेट करता है कि उसने ऐसा किया है।

दूसरी पंक्ति (एनबी एम्बेडेड न्यूलाइन) इनपुट समाप्त होने तक पीछे हटती है, स्ट्रिंग के पहले एन वर्णों को प्रिंट करती है , फिर $ 1 से हटाए गए पहले चरित्र के साथ खुद को आमंत्रित करती है।

डेबियन के साथ परीक्षण किया /bin/dash- नमूना आउटपुट का पालन करें:

./marquee "परीक्षण" 4

   t
  te
 tes
test
esti
stin
ting
ing
ng
g

./marquee "कुछ अधिक लंबा" 10

         S
        So
       Som
      Some
     Somet
    Someth
   Somethi
  Somethin
 Something
Something 
omething a
mething a 
ething a b
thing a bi
hing a bit
ing a bit 
ng a bit l
g a bit lo
 a bit lon
a bit long
 bit longe
bit longer
it longer
t longer
 longer
longer
onger
nger
ger
er
r

./marquee "छोटा" 15

              s
             sm
            sma
           smal
          small
         small
        small
       small
      small
     small
    small
   small
  small
 small
small
mall
all
ll
l

— टोबी स्पाईट
स्रोत

-10 बोनस पाने के लिए मैं 9 चार्ट जोड़ सकता हूं! [ "$ 1"] && printf "% -। $ {2} s" "$ 1" "" && नींद 1 && $ 0 "$ {1 #?}" $ 2 टी

— टोबी स्पीट

3

पायथन 2, 51 बाइट्स / 37 बाइट्स

बिना हार्डकोड इनपुट (51 बाइट्स):

def f(s,n):
 s=" "*n+s
 while s:print s[:n];s=s[1:]

जैसे बुलाओ f("testing", 4) ।

हार्डकोड इनपुट (37 बाइट्स) के साथ:

s="testing";n=4

s=" "*n+s
while s:print s[:n];s=s[1:]

दोनों संस्करण रिक्त स्थान की एक प्रारंभिक रेखा का उत्पादन करते हैं।

— Sp3000
स्रोत

3

पायथन 2, (54 बाइट्स - 10 = 44) 64 62 60 46

(मुझे लगता है कि हार्ड-कोडित इनपुट के लिए लाइन बाइट काउंट को नहीं जोड़ती है।)

मुझे अभी तक ऐसा कोई कार्यक्रम नहीं दिखाई दिया जो वास्तव में प्रिंटिंग लाइनों के बीच सोता हो, इसलिए मैंने एक ऐसा किया, जो इस तरह से एक मार्की की तरह दिखता है। यह कार्यक्रम पायथन 3 में 2 और बाइट्स है।

संपादित करें: कार्यक्रम अब सोने के बजाय एक संगणना करता है। मैंने iगणना में उपयोग किया ताकि प्रोग्राम इसे एक स्थिर के रूप में संग्रहीत न करे, लेकिन इसे हर बार गणना करना चाहिए।

अजगर 3 एक यहाँ की कोशिश करो (अजगर 2 उत्तर छोटी गाड़ी है)

i=0
while s[i-n:]:print((' '*n+s)[i:n+i]);i+=1;i**7**7

— mbomb007
स्रोत

शायद इसके बजाय time.sleepकुछ लंबी संगणना है जिसका आप उपयोग कर सकते हैं? इसके अलावा, whileलूप का उपयोग करना थोड़ा कम है :i=0\nwhile s[i-n:]:print(' '*n+s)[i:n+i];i+=1

— xnor

@ एक्सनोर एक्सपेंशनशिप एक दो बार गणना के लिए बहुत अच्छी तरह से काम करता है।

— mbomb007

@ mbomb007 मुझे नहीं लगता कि आपको वास्तव में ऐसा करने के लिए अजगर को प्राप्त करने के लिए गणना के मूल्य को संग्रहीत करने की आवश्यकता है (इसलिए आप 'q =' को बचा सकते हैं)। इसके अलावा, x ^ 7 ^ 7 गणितीय रूप से x ^ 49 के बराबर है, हालांकि अजगर मेरे लिए उत्तरार्द्ध को थोड़ा तेजी से हल करता है। आप इस तरह से कुछ पात्रों को बचा सकते हैं।

— सोमपोम

@Somom उत्तर में इसे आज़माएं। यदि मैं अभिव्यक्ति को एक एकल घातांक में समेकित करता हूं, तो यह समय की देरी को पूरी तरह से हटा देता है। लेकिन मैं निकाल दूंगा q=। धन्यवाद।

— mbomb007

@Somom Exponentiation सही-सहयोगी है, इसलिए यह वास्तव में हैi**(7**7)

— Sp3000

3

पायथ, 12 बाइट्स

jb.:X*dyQQzQ

प्रदर्शन।

पायथ, 17 - 10 = 7 बाइट्स

FN.:X*dyQQzQ&.p9N

यह संस्करण लाइन प्रिंट के बीच देरी को नियोजित करता है। यह कमांड लाइन कंपाइलर पर देखा जा सकता है, जिसे आप प्राप्त कर सकते हैं यहां हैं ।

निम्नलिखित चलाएँ:

pyth -c 'FN.:X*dyQQzQ&.p9N' <<< 'testing
4'

इससे प्रत्येक प्रिंट से पहले लगभग 0.3 सेकंड की देरी होती है। यदि आप अधिक विलंब पसंद करते हैं, तो आप इसका उपयोग कर सकते हैं:

FN.:X*dyQQzQ&.pTN

इसके बारे में 4 सेकंड की देरी है।

— isaacg
स्रोत

3

जावा, 133 119 115

int i;void f(String s,int n){for(;++i<n;)s=" "+s+" ";for(;i<=s.length();)System.out.println(s.substring(i-n,i++));}

दीर्घ संस्करण:

int i;
void f(String s, int n) {
    for(; ++i < n;)
        s = " " + s + " ";
    for(; i<=s.length();)
        System.out.println(s.substring(i-n, i++));
}

पैडिंग स्ट्रिंग पर लागू होती है, और फिर पैडेड स्ट्रिंग के सब्सट्रिंग को कंसोल पर प्रिंट किया जाता है।

-4 बाइट्स @KevinCruijssen को धन्यवाद।

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

मुझे पता है कि यह एक वर्ष से अधिक हो गया है, लेकिन आप दूसरे के लिए थोड़ा-थोड़ा कर सकते हैं: for(;i<= s.length();System.out.println(s.substring(i-n,i++)));( -3 बाइट्स )

— केविन क्रूज़सेन

1

इसका मतलब यह नहीं है कि इसमें सुधार नहीं किया जा सकता है। :) धन्यवाद।

— टीएनटी

2

मतलूब, ९ ५

हमेशा की तरह, यह मैट्रिस का हेरफेर है। यहाँ मुख्य कमांड है spdiagsजो आपको बहुत आसानी से विकर्ण मैट्रिसेस बनाने की अनुमति देता है।

t=input('');
n=numel(t);
k=input('');
flipud(char(full(spdiags(repmat(t,n+k-1,1),1-n:0,n+k-1,k))))

हार्डकोडिंग के साथ 71 बाइट्स (अपेक्षित स्ट्रिंग संग्रहीत tऔर संख्या में k)

n=numel(t);flipud(char(full(spdiags(repmat(t,n+k-1,1),1-n:0,n+k-1,k))))

— flawr
स्रोत

2

एपीएल, 50 - 10 = 40 चार्ट

मुझे यकीन है कि यह छोटा हो सकता है। 50 दो स्थिरांक के बिना कार्यक्रम की लंबाई है।

{⍵≡⍬:⍬⋄⎕←↑⍵⋄⎕DL 99⋄∇1↓⍵}⊂[0]⊖s⍴⍨n,¯1+⍴s←'brace yourself',' '⍴⍨n←6

स्पष्टीकरण:

                               ' '⍴⍨n←6   call the number 'n' and make n spaces
            s←'brace yourself',           append them to the string and call it 's'
⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
                             s⍴⍨n,¯1+⍴s   make a len(s)-1 by n matrix by repeating s 
                        ⊂[0]⊖             reflect the matrix and extract the columns
{                      }                  pass the list of columns to this function
 ⍵≡⍬:⍬⋄                                   return if the list is empty
       ⎕←↑⍵⋄                              print the first column (as a row)
            ⎕DL 99⋄                       wait for 99ms
                   ∇1↓⍵                   recurse with the rest of the columns

टर्मिनल पर ngn APL के लिए विकसित किया गया।

— Tobia
स्रोत

2

पॉवर्सशेल - 85 83 बाइट्स

यह देर हो चुकी है, यह जीतने वाला नहीं है :-) लेकिन मैंने सोचा कि मैं पूर्णता के लिए एक पॉवर्सशेल में फेंक दूंगा:

function m($s,$n){1..$($n+$s.length)|%{-join(" "*$n+$s+" "*$n)[$_-1..$($n+$_-1)]}}

— क्रिस जे
स्रोत

1

कोबरा - 60

def f(n,s)
    s=' '.repeat(n)+s
    while''<s,print (s=s[1:])[:n]

— Οurous
स्रोत

1

ग्रूवी - 82

n=args[1]as int;t=" "*n+args[0]+" "*n;(0..t.size()-n).each{println t[it..it+n-1]}

— dbramwell
स्रोत

1

लूआ, 79 बाइट्स

r=io.read;t=r()w=r()s=" "t=s:rep(w)..t;for i=1,t:len()do print(t:sub(i,i+w))end

— गप्पी
स्रोत

1

सी #, 112 बाइट्स

s=>n=>{var r=new string(' ',n-1);s=r+s+r;r="";for(int i=0;i<s.Length-n+1;)r+=s.Substring(i++,n)+"\n";return r;};

पूर्ण कार्यक्रम ungolfed विधि और परीक्षण मामलों के साथ:

using System;

namespace FakeMarqueeText
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,Func<int,string>>f= s=>n=>
            {
                var r=new string(' ',n-1);
                s=r+s+r;
                r="";
                for(int i=0;i<s.Length-n+1;)
                    r+=s.Substring(i++,n)+"\n";

                return r;
            };

            // test cases:
            Console.WriteLine(f("testing")(4));
            Console.WriteLine(f("hello")(2));
            Console.WriteLine(f("foobarz")(3));
            Console.WriteLine(f("Something a bit longer")(10));
            Console.WriteLine(f("small")(15));
            Console.WriteLine(f("aaa")(3));
            Console.WriteLine(f("brace yourself")(6));

        }
    }
}

— adrianmp
स्रोत

1

जेली , 15 बाइट्स - 10 = 5 ( गैर-प्रतिस्पर्धात्मक ?)

ḶṚ⁶ẋ;€⁹ZṄœS$€ṛ“

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

प्रत्येक पंक्ति के बीच एक दूसरे के लिए सोता है। यदि यह स्वीकार्य है, तो एक अनुगामी न्यूलाइन प्रिंट करता है।

^{याय जैली ने चारकोल को हराया}

— आउटग्रॉफर को एरिक करें
स्रोत

1

PHP4.1, 85-10 = 75 बाइट्स

हां, यह बहुत पुराना संस्करण है, लेकिन इसकी एक कार्यक्षमता है जिसकी मुझे आवश्यकता है।
आप इसे अभी भी PHP के किसी भी हाल के संस्करण में चला सकते हैं, लेकिन आपको नीचे दिए गए कोड को चलाने से पहले चर को स्वयं सेट करना होगा।

यह मेरे कोड के आकार को कम करने में मेरी बहुत मदद करता है!

यह वास्तव में बुनियादी है:

<?for($s=str_repeat(' ',$n).$s;$i++<strlen($s)+$n;sleep(1))echo substr($s,$i,$n),'
';

मैं इस वजह से बोनस के लिए दौड़ा, ओपी को उद्धृत करते हुए:

यदि आपका प्रोग्राम स्टैंडअलोन है (अर्थात जब रन वास्तव में लाइनों को प्रिंट करता है) (इनपुट को हार्ड-कोडित लेकिन बदलने में आसान हो सकता है) और आउटपुट की प्रत्येक पंक्ति के बीच थोड़ा सा सोता है जो आपको -10 बोनस मिलता है।

जैसा कि आप स्पष्ट रूप से देख सकते हैं, इसमें एक नींद है।

यह मान लेता है कि आपने register_globalsडिफ़ॉल्ट रूप से सक्षम किया है, जो इस संस्करण के लिए डिफ़ॉल्ट सेटिंग्स थे।

आप आसानी से अपने ब्राउज़र में, के साथ परीक्षण कर सकते हैं ~~कम से कम~~ कुछ परिवर्तन:

//detects if it is running in js or php
//true for js, false for php
if('\0'=="\0")
{
	function strlen($s){
		return $s.length;
	}
	
	function str_repeat($s,$n){
		return Array($n+1).join($s);
	}
	
	function substr($s,$n,$m){
		return $s.substr($n,$m);
	}
	
	function printf($s){
		document.write($s);
	}
	
	function concat($a,$b){
		return $a+$b;
	}
}
else
{
	function concat($a,$b){
		return $a.$b;
	}
}

//sets the variables, not required for PHP if you pass the values by GET or POST
$i=0;
$s='example';
$n=6;



for($s=concat(str_repeat('-',$n),$s);$i++<strlen($s)+$n;)printf(concat(substr($s,$i,$n),'<br>'));

*{font-family:monospace}

स्निपेट का विस्तार करें

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

परिवर्तनों की सूची:

sleep(1)इस परीक्षण में हटा दिया गया
फ़ंक्शन के 2 संस्करण बनाए गए concat
लक्ष्य पीएचएन और जेएस मतभेदों को दूर करने वाले तारों को दूर करना है।
अंतरिक्ष के बजाय, अंतरिक्ष -को भरने के लिए एक का उपयोग किया जाता है
इसके बजाय echo, printfका उपयोग करता है (PHP सीमा)
इसके बजाय या 'वास्तविक' newline, के <br>बजाय का उपयोग करता है

— इस्माइल मिगुएल
स्रोत

1

जे , 15 14 बाइट्स

,.~/@(' '&,~<)

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

— मील की दूरी पर
स्रोत

1

एपीएल (डायलॉग) , 17 बाइट्स

⌽⍉↑(⎕,⍨' '/⍨⊢)¨⍳⎕

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

(कार्यक्रम मानता है ⎕IO←0जो कई मशीनों पर डिफ़ॉल्ट है)

व्याख्या

⍳⎕               Create a range 0 .. input-1
¨                For each element in this range do:
 ' '/⍨⊢           A space duplicated right argument (which is the element in  the range) times
 ⎕,⍨              Concatenated with the input string to its right
⌽⍉               Transpose and reflect horizontally

— क्रिकटी लिथोस
स्रोत

नकली मार्की पाठ

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

व्याख्या

19 - 10 = 9?

सी, 69 बाइट्स

पायथ, 13 बाइट्स

व्याख्या

पायथन 65 63

जावास्क्रिप्ट ( ईएस 7 ड्राफ्ट ), 61 बाइट्स

जावास्क्रिप्ट ( ES6 ) हार्डकोड इनपुट, 47 बाइट्स

के, 19 बाइट्स

जे (22)

जूलिया, 75 बाइट्स

QBasic, 56 - 10 = 46

रूबी, 68 , 55 बाइट्स

हास्केल, 61 59 54 बाइट्स

बैश, 109 - 10 = 99 बाइट्स

शुद्ध बैश, 61 बाइट्स

आउटपुट:

पर्ल, 50

POSIX खोल, 94

पायथन 2, 51 बाइट्स / 37 बाइट्स

पायथन 2, (54 बाइट्स - 10 = 44) 64 62 60 46

पायथ, 12 बाइट्स

पायथ, 17 - 10 = 7 बाइट्स

जावा, 133 119 115

मतलूब, ९ ५

एपीएल, 50 - 10 = 40 चार्ट

पॉवर्सशेल - 85 83 बाइट्स

कोबरा - 60

ग्रूवी - 82

लूआ, 79 बाइट्स

सी #, 112 बाइट्स

जेली , 15 बाइट्स - 10 = 5 ( गैर-प्रतिस्पर्धात्मक ?)

PHP4.1, 85-10 = 75 बाइट्स

जे , 15 14 बाइट्स

एपीएल (डायलॉग) , 17 बाइट्स

व्याख्या