लंबवत पाठ को संक्षिप्त करें

Question

कहो कि मेरे पास इस तरह का पाठ है (एक पंक्ति में प्रत्येक शब्द, जिसमें कोई स्थान नहीं है)

Programming
Puzzles
&
Code
Golf

इसका कोई अर्थ नही बन रहा है! यह पूरी तरह से भौतिकी के नियमों को धता बताता है।

आपकी चुनौती इस असंभव स्थिति को दूर करने और इस तरह से पाठ को ढहाने की है:

P
Prog
&uzz
Coderam
Golflesming

ताकि किसी पात्र के नीचे कोई खाली जगह न रहे लेकिन पात्र अपने ऊर्ध्वाधर क्रम को बनाए रखते हैं।

लक्ष्य आवश्यकताओं को पूरा करना है लेकिन स्रोत कोड के सबसे कम बाइट्स का उपयोग करना संभव है।

Comments

इसके अलावा, क्या यह प्रति पंक्ति एक शब्द होगा, या रिक्त स्थान हो सकते हैं? यदि रिक्त स्थान हैं, तो क्या वे नीचे गिर सकते हैं, या क्या अंतरिक्ष भार सहन कर सकते हैं?

— ग्लेन ओ

"पी प्रोग और उज़ कोडारम गोल्फसिंग", ऐसा लगता है कि साइट के शीर्षक के लिए एक नया उम्मीदवार है ..

— jcai

किसी के मार्बलस ( github.com/marbelous-lang/marbelous.py ) का उपयोग करने जा रहा है ?

— चार्ली

मैं एक भौतिकी इंजन का उपयोग करने का फैसला करता हूं और 0 बाइट

— l4m2

क्या आउटपुट में अनुगामी स्थान हो सकते हैं?

— एर्ग आउटफोलर

Answer 1

अजगर, 10 बाइट्स

jb_.T.T_.z

इसे Pyth Compiler / Executor में ऑनलाइन आज़माएँ ।

विचार

हम चार सरल परिवर्तनों को लागू करके वांछित उत्पादन प्राप्त कर सकते हैं:

1. लाइनों के क्रम को उल्टा करें:

   Golf
   Code
   &
   Puzzles
   Programming
   

2. स्थानान्तरण पंक्तियाँ और स्तंभ:

   GC&PP
   oour
   ldzo
   fezg
   lr
   ea
   sm
   m
   i
   n
   g
   

   यह शीर्ष मूल स्तंभों को ध्वस्त करता है।

3. स्थानान्तरण पंक्तियाँ और स्तंभ:

   Golflesming
   Coderam
   &uzz
   Prog
   P
   

4. लाइनों के क्रम को उल्टा करें:

   P
   Prog
   &uzz
   Coderam
   Golflesming
   

कोड

        .z  Read the input as a list of strings, delimited by linefeeds.
       _    Reverse the list.
   .T.T     Transpose the list twice.
  _         Reverse the list.
jb          Join its strings; separate with linefeeds.

Comments

जीआर, बिल्कुल इस पोस्ट करने वाला था :)। इसके बजाय एक उत्थान है।

— माल्टीसेन

मेरे पास भी कुछ इसी तरह की पोस्ट करने की योजना थी ... अपवोटिंग भी

— वैल्ली वेस्ट

यदि आप आदेश को उलटने से पहले पंक्तियों और स्तंभों को स्थानांतरित करते हैं तो क्या होगा?

— जॉन ऑमेड

@ जॉनोहोम बस दो बार ट्रांसपोज़ करने से पात्रों को नीचे की ओर ले जाने के बजाय शीर्ष पर ले जाएगा। आप ट्रांसपोज़ करके शुरू कर सकते हैं, तब तक आपको प्रत्येक पंक्ति को उल्टा करना होगा, जो कि एक बाइट होगी।

— डेनिस

पवित्र फॉक्सप्रो, यह चतुर था।

— वर्क ओवरफ्लो

Answer 2

हास्केल, 62 बाइट्स

import Data.List
p=reverse;o=transpose
f=unlines.p.o.o.p.lines

मैं बहुत परिपक्व हूं।

Comments

+1 क्योंकि मैं कभी-कभी हास्केल, और पोपिंग लाइनों के लिए देखता हूं।

— Carcigenicate

Answer 3

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

l=[]
for x in input().split('\n'):n=len(x);l=[a[:n]+b[n:]for a,b in zip(l+[x],['']+l)]
print'\n'.join(l)

एक पुनरावृत्त एक-पास एल्गोरिथ्म। हम क्रम में प्रत्येक पंक्ति से गुजरते हैं, lलाइनों की सूची को आउटपुट में अपडेट करते हैं । नया शब्द प्रभावी रूप से नीचे से धकेलता है, ऊपर के सभी अक्षरों को एक स्थान पर स्थानांतरित करता है। उदाहरण के लिए, परीक्षण के मामले में

Programming
Puzzles
&
Code
Golf

Codeहमारे पास करने के बाद , हमारे पास है

P
Prog
&uzzram
Codelesming

और फिर में Golfपरिणाम जोड़ने

P
Prog
&uzz
Coderam
Golflesming

जिसे हम दो टुकड़ों के संयोजन के रूप में देख सकते हैं

P     |
Prog  |
&uzz  |
Code  | ram
Golf  | lesming

जहां पहला टुकड़ा द्वारा स्थानांतरित कर दिया गया golf। हम इस शिफ्टिंग zipको अंतिम (बाईं ओर) तत्व के साथ आउटपुट सूची के साथ करते हैं और आउटपुट लाइन पूर्ववर्ती स्थिति को एक खाली लाइन (दाईं ओर), प्रत्येक भाग को नए तत्व की लंबाई में काटते हैं।

यह बजाय पीछे की ओर पुनरावृति करने के लिए और अधिक स्वाभाविक लग सकता है, नए अक्षरों को ऊपर से गिरना, लेकिन उस समय मेरा प्रयास लंबा हो गया।

तुलना के लिए, यहां (ए zip/ filterअप्रोच, 109 बाइट्स के लिए) का map(None,*x)उपयोग किया गया है iziplongest:

f=lambda z:[''.join(filter(None,x))for x in map(None,*z)]
lambda x:'\n'.join(f(f(x.split('\n')[::-1]))[::-1])

Answer 4

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

qN/W%zzW%N*

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

मेरे पाइथ के उत्तर के समान ही विचार ।

q           e# Read from STDIN.
 N/         e# Split at linefeeds.
   W%       e# Reverse the resulting array.
     zz     e# Transpose it twice.
       W%   e# Reverse the resulting array.
         N* e# Join its strings; separate with linefeeds.

Answer 5

जावास्क्रिप्ट (ईएस 6), 146

(टेम्प्लेट स्ट्रिंग्स के अंदर 2 नए समाचार महत्वपूर्ण और गिने जाते हैं)

@Dennis का विचार जावास्क्रिप्ट में लागू किया गया। लंबा S फ़ंक्शन ट्रांसपोज़िशन लाइन को लाइन और चार द्वारा चार कर देता है, परिणाम tसरणी में छोड़ देता है ।

a=>(S=z=>{for(t=[];z.join``;t.push(w))for(w='',n=z.length;n--;z[n]=z[n].slice(1))w+=z[n][0]||''},S(a.split`
`),S(t.reverse()),t.reverse().join`
`)

स्निपेट के अंदर कम गोल्फ (फ़ायरफ़ॉक्स में प्रयास करें)

F=a=>(
  S=z=>{
    for(t=[];z.join``;t.push(w))
      for(w='',n=z.length;n--;z[n]=z[n].slice(1))
        w+=z[n][0]||''
  },
  S(a.split`\n`),
  S(t.reverse()),
  t.reverse().join`\n`
)

#I,#O { margin:0; width: 200px; height:100px; border: 1px solid #ccc }

<table><tr><td>
Input<br><textarea id=I>Programming
Puzzles
&
Code
Golf
</textarea></td><td>
Output<pre id=O></pre>
</td></tr></table>  
<button onclick='O.innerHTML=F(I.value)'>go</button>

Comments

के S(t.reverse()),t.reverse().joinसाथ बदलकर कुछ बाइट्स कम करें S(R=t.reverse()),R.join।

— इस्माइल मिगुएल

@IsmaelMiguel नहीं, S में परिवर्तन होता है, इसलिए S के बाद t, S से पहले t के समान नहीं है

— edc65

Answer 6

आर, 223 बाइट्स

function(x){a=apply(do.call(rbind,lapply(p<-strsplit(strsplit(x,"\n")[[1]],""),function(x)c(x,rep(" ",max(lengths(p))-length(x))))),2,function(x)c(x[x==" "],x[x!=" "]));for(i in 1:nrow(a))cat(a[i,][a[i,]!=" "],"\n",sep="")}

यह एक बेतुका लंबा, भोला तरीका है।

Ungolfed:

f <- function(x) {
    # Start by spliting the input into a vector on newlines
    s <- strsplit(x, "\n")[[1]]

    # Create a list consisting of each element of the vector
    # split into a vector of single characters
    p <- strsplit(s, "")

    # Pad each vector in p to the same length with spaces
    p <- lapply(p, function(x) c(x, rep(" ", max(lengths(p)) - length(x))))

    # Now that the list has nice dimensions, turn it into a matrix
    d <- do.call(rbind, p)

    # Move the spaces to the top in each column of d
    a <- apply(d, 2, function(x) c(x[x == " "], x[x != " "]))

    # Print each row, omitting trailing whitespace
    for (i in 1:nrow(a)) {
        cat(a[i, ][a[i, ] != " "], "\n", sep = "")
    }
}

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

Answer 7

मतलाब / ऑक्टेव, 99 बाइट्स

function f(s)
c=char(strsplit(s,[10 '']));[~,i]=sort(c>32);[m,n]=size(c);c(i+repmat((0:n-1)*m,m,1))

उदाहरण :

एक चर में एक इनपुट स्ट्रिंग को परिभाषित करें, कहते हैं s। 10पंक्ति फ़ीड वर्ण है:

>> s = ['Programming' 10 'Puzzles' 10 '&' 10 'Code' 10 'Golf'];

fइनपुट के साथ कॉल फ़ंक्शन s:

>> f(s)
ans =
P          
Prog       
&uzz       
Coderam    
Golflesming

या इसे ऑनलाइन आज़माएं ( ऑनलाइन ऑक्टेव दुभाषिया की मदद के लिए @beaker के लिए धन्यवाद )

Answer 8

जावास्क्रिप्ट ईएस 6, 119 बाइट्स

F=s=>(C=o=>--a.length?C(a.reduce((p,c,i)=>c+p.slice((a[i-1]=p.slice(0,c.length)).length)))+`
`+o:o)(a=(s+`
`).split`
`)

यहाँ यह असंयमी है और ES5 में टिप्पणियों के साथ यह बताता है कि यह कैसे काम करता है:

function F(s) {
  var arr = (s+'\n').split('\n'); // Create an array of words and append an empty member
  return (function C(output) {
    return --arr.length ? // Remove the last item from the array
      C(arr.reduce(function(p,c,i) { // If the array still has length reduce it to a string and recurse
        var intersection = (arr[i-1] = p.slice(0, c.length)) // Overwrite the previous word with the part that intersects the current word
        return c + p.slice(intersection.length) // Add the part of the previous word that doesn't intersect to the current value
      })) + '\n' + output : output // Add the last level of recursions output on to the end of this
  })(arr);
}

input.addEventListener('input', updateOutput, false);

function updateOutput() {
  var oldLength = input.value.length;
  var start = this.selectionStart;
  var end = this.selectionEnd;
  input.value = input.value.split(/ +/).join('\n');
  var newLength = input.value.length;
  input.setSelectionRange(start, end + (newLength - oldLength));
  output.value = F(input.value).trim();
}

updateOutput();

textarea {
  width: 50%;
  box-sizing: border-box;
  resize: none;
  float: left;
  height: 10em;
}

label {
  width: 50%;
  float: left;
}

<p>Type in the input box below, spaces are automatically converted to newlines and the output updates as you type</p>
<label for="input">Input</label>
<label for="output">Output</label>
<textarea id="input">
Type inside me :)
</textarea>
<textarea id="output" disabled>
</textarea>

Answer 9

एपीएल (डायलॉग एक्सटेंडेड) , 13 11 बाइट्स ^{एसबीसीएस}

-2 Dyalog APL के लिए मेरे एक्सटेंशन के साथ।

अनाम टिशिट फ़ंक्शन, एक वर्ण मैट्रिक्स को लेना और वापस करना।

~∘' '⍤1⍢⍉⍢⊖

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

~ हटाने  रिक्त स्थान  से  पंक्तियों (शाब्दिक अर्थ -1 डी उप सरणियों)  जबकि  स्थानांतरित  जबकि  फ़्लिप
∘
' '
⍤
1
⍢
⍉
⍢
⊖

Comments

प्रतीक्षा करें कि यह 33 बाइट्स कैसे है?

— कॉनर ओ'ब्रायन

Answer 10

आर, 190 178 175 बाइट्स

शायद अभी भी इसमें गोल्फ के लिए कुछ जगह है। संभवत: वहां कुछ अनावश्यक ऑपरेशन हुए

l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')

अनगढ़ और समझाया गया

a<-scan(,'')    # get STDIN
h<-length(a)    # number of lines
w=max(nchar(a)) # length of longest line
M<-lapply(a,substring,1:w,1:w)   # create a list of split strings with empty chars
M<-do.call(rbind,M)[h:1,]        # turn it into a matrix with line order reversed
M<-apply(M,1,paste0,collapse='') # paste together the columns
M<-lapply(M,substring,1:h,1:h)   # split them back up
M<-do.call(rbind,M)[,h:1]        # reform a matrix
M<-rbind(M,'\n')                 # add some carriage returns
cat(M,sep='')   # output with seperators

परीक्षण चालन। यह ध्यान रखना दिलचस्प है कि स्कैन करने के तरीके के कारण, पूरा वाक्य रिक्त स्थान के साथ इनपुट हो सकता है और फिर भी आउटपुट को निर्दिष्ट के रूप में दे सकता है।

> l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')
1: Programming
2: Puzzles
3: &
4:     Code
5: Golf
6: 
Read 5 items
P
Prog
&uzz
Coderam
Golflesming
> l=lapply;s=substring;C=rbind;d=do.call;cat(C(d(C,l(apply(d(C,l(a<-scan(,''),s,1:(w=max(nchar(a))),1:w))[(h=length(a)):1,],2,paste0,collapse=''),s,1:h,1:h))[,h:1],'\n'),sep='')
1: Programming Puzzles & Code Golf beta
7: 
Read 6 items
P
Prog
&uzz
Code
Golfram
betalesming
>   

Answer 11

STATA, 323 बाइट्स

अब नामक एक फ़ाइल में इनपुट लेता है केवल 24 वर्णों तक काम करता है। बाद में इसे और अधिक के साथ काम करने के लिए अद्यतन करेगा। इसके अलावा, ऑनलाइन कंपाइलर में काम नहीं करता है। गैर-मुक्त संकलक की आवश्यकता है।

gl l=24/
forv x=1/$l{
gl a="$a str a`x' `x'"
}
infix $a using a.b
gl b=_N
forv k=1/$l{
gen b`k'=0
qui forv i=$b(-1)1{
forv j=`i'/$b{
replace b`k'=1 if _n==`j'&a`k'==""
replace a`k'=a`k'[_n-1] if _n==`j'&a`k'==""
replace a`k'="" if _n==`j'-1&b`k'[_n+1]==1
replace b`k'=0
}
}
}
forv i=1/$b{
forv k=1/$l{
di a`k'[`i'] _c
}
di
}

संपादित करें: 8 बाइट्स को बचाते हुए, लूप में प्रत्येक स्टेटमेंट से लूप को चुपचाप (आउटपुट को दबाने के लिए) ले जाया गया।

Comments

आपका जमा अमान्य क्यों होगा, सिर्फ इसलिए कि उसे गैर-मुक्त संकलक की आवश्यकता है?

— डेनिस

@ डेनिस ने सोचा कि मेटा में निर्णय लिया गया था कि प्रोग्रामिंग भाषाओं को कुछ मुक्त वातावरण में चलाने योग्य होना चाहिए। इसके अलावा, इनपुट लंबाई पर प्रतिबंध इसे अमान्य कर सकता है।

— हस्ताक्षर

चरित्र प्रतिबंध एक समस्या होगी, लेकिन मुझे ऐसी किसी भी आम सहमति के बारे में जानकारी नहीं है जिसके लिए एक नि: शुल्क कार्यान्वयन की आवश्यकता है। (यदि आपको हैलो वर्ल्ड क्विज़ से यह विचार मिला, तो यह प्रश्न स्पष्ट रूप से मुक्त भाषाओं के लिए पूछा गया था।)

— डेनिस

@ डेनिस मुझे लगा कि यह सर्वसम्मति है: meta.codegolf.stackexchange.com/questions/988/…

— हस्ताक्षर

जवाब से पता चलता है कि अस्थिर पोस्टों को अस्वीकार कर दिया जाता है, जिसमें वास्तव में आम सहमति की आवश्यकता नहीं होती है, और व्यवहार में ऐसा नहीं होता है। वास्तव में, गणितज्ञ और TI-BASIC उत्तर आमतौर पर काफी लोकप्रिय हैं।

— डेनिस

Answer 12

आर, 171 बाइट्स

S=scan(,"");while(any((D<-diff(N<-sapply(S,nchar)))<0)){n=max(which(D<0));S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]));S[n]=substr(S[n],1,N[n]+D[n])};cat(S,sep="\n")

नई सूचियों और इंडेंटेशन के साथ:

S=scan(,"") #Takes input from stdin
while(any((D<-diff(N<-sapply(S,nchar)))<0)){
    n=max(which(D<0))
    S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]))
    S[n]=substr(S[n],1,N[n]+D[n])
}
cat(S,sep="\n")

उपयोग:

> S=scan(,"");while(any((D<-diff(N<-sapply(S,nchar)))<0)){n=max(which(D<0));S[n+1]=paste0(S[n+1],substr(S[n],N[n]+D[n]+1,N[n]));S[n]=substr(S[n],1,N[n]+D[n])};cat(S,sep="\n")
1: Programming
2: Puzzles
3: &
4: Code
5: Golf
6: 
Read 5 items
P
Prog
&uzz
Coderam
Golflesming

Answer 13

जेली , 6 बाइट्स (गैर-प्रतिस्पर्धात्मक)

ỴṚZZṚY

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

यह काम किस प्रकार करता है

मेरे पाइथ के उत्तर के समान ही विचार ।

ỴṚZZṚY  Main link. Argument: s (string)

Ỵ       Split at linefeeds.
 Ṛ      Reverse the order of the lines.
  ZZ    Zip/transpose twice.
    Ṛ   Reverse the order of the lines.
     Y  Join, separating by linefeeds.

Answer 14

टर्टल , 72 बाइट्स, नॉन-कंपेटिंग

बहुत यकीन है कि मैं बाइट्स को बचाने के लिए दृष्टिकोण बदल सकता था, लेकिन बाद में।

: पी नॉन-गोल्फ एसोलैंग बीट्स रेगुलर लैंग्स: पी

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

Turtlèd newline input नहीं ले सकता है, लेकिन कई इनपुट्स के लिए, और इसमें केवल एक इनपुट लेता है: प्रत्येक शब्द को अंतिम सहित एक स्थान के साथ समाप्त करें।

!l[*,+r_][ l]ur[*,[ -.]+.[ r{ d}u+.]-.[ -.]{ l}[ l]r[ u]_]' d[ d]u[ ' r]

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

स्पष्टीकरण:

!                          Take string input
 l                         Move left, off the asterisk at the start of grid
  [*    ]                  Until cell is *
    ,+r_       write *, string pointer+=1, move right, write * if pointed char is last char
         [ l]ur    move left until finding a space, move up and right
               [*                                        ]     Until cell is *
                 ,                               write *
                  [   ]             until cell is [space]
                    -.               decrement string pointer, write pointed char
                       +.           increment and write string pointer
                         [         ] until cell is [space]
                           r{ d}     move right, move down until finding nonspace
                                u+.  move up, string pointer+=1 and write pointed char
                                    -.      decrement string pointer and write pointed char
                                      [   ]  until cell is [space]
                                        -.  string pointer-=1 and write pointed char
                                           { l}   move left until finding nonspace
                                               [ l]   move left until finding space
                                                   r   move right
                                                    [ u]  move up until finding space
                                                        _  write * if pointed char is last char
                                                          (if it is written, loop ends)

                                                          ' d[ d]u[ ' r] just cleanup

Answer 15

पर्ल, 133 बाइट्स

यह उन चुनौतियों में से एक थी जो मेरे सिर में बहुत मुश्किल से बदल रही थी, आसान होने के लिए, मैं अनुमान से बहुत अधिक कोड होने के कारण ... मैं दृष्टिकोण से विशेष रूप से खुश नहीं हूं, मुझे यकीन है कि ए बहुत बेहतर तरीका print pop@F...शायद बिट का उपयोग करके -nया सिर्फ शुद्ध रेगेक्स को कम करना है , लेकिन मैं अभी वहां नहीं पहुंच सकता ... मूल रूप से मैं उपयोग कर रहा था say, लेकिन मुझे लगता है कि मुझे इसकी use 5.01वजह से उच्च ( ) स्कोर करना होगा $'।

@F=(/.+/g,@F)for<>;$_%=$#F,($x=length$F[$_++])<length$F[$_]&&($F[$_]=~/.{$x}/,$F[$_-1].=$',$F[$_]=$&)for 0..1e2;print pop@F,$/while@F

प्रयोग

के रूप में सहेजें vertically-collapse-text.pl।

perl vertically-collapse-text.pl <<< 'Programming
Puzzles
&
Code
Golf'
P
Prog
&uzz
Coderam
Golflesming

Answer 16

स्माइलबासिक, 90 बाइट्स

X=RND(50)Y=RND(20)G=CHKCHR(X,Y+1)<33LOCATE X,Y+G?CHR$(CHKCHR(X,Y));
LOCATE X,Y?" "*G
EXEC.

कंसोल में सभी पाठ पर गुरुत्वाकर्षण लागू करता है। मुझे यकीन नहीं है कि यह वैध है, या अगर मुझे एक स्ट्रिंग सरणी का उपयोग करना है।

Answer 17

रूबी, 99 82 बाइट्स

वहाँ पर होना...

f=->a,i=-1{a.map{|l|i+=1;(0...l.size).map{|c|a.map{|x|x[c]}.join[~i]}*''}.reverse}

एक स्पष्टीकरण का प्रयास:

f=->a,i=-1{a.map{|l|i+=1; # For each line `l` with index `i` in string array `a`
(0...l.size).map{|c|        # For each column `c` in `l`
a.map{|x|x[c]}.join           # Make a string of non-nil characters `c` across `a`...
[~i]                          # ...and grap the `i`th character *from the end*, if any
}*''}.reverse}              # Join the characters grabbed from each column and reverse the result

इसे इस तरह चलाएं:

a = %w[
  Programming
  Puzzles
  &
  Code
  Golf
]
puts f[a]

Answer 18

के, ३०

{+{(-#x)$x@&~^x}'+x@\:!|/#:'x}

।

k){+{(-#x)$x@&~^x}'+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"P          "
"Prog       "
"&uzz       "
"Coderam    "
"Golflesming"

व्याख्या

x@\:!|/#:'x एक वर्गाकार चार मैट्रिक्स बनाने के लिए प्रत्येक स्ट्रिंग का विस्तार करता है।

k){x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"Programming"
"Puzzles    "
"&          "
"Code       "
"Golf       "

+ इसे स्थानांतरित करता है

k){+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"PP&CG"
"ru oo"
"oz dl"
"gz ef"
"rl   "
"ae   "
"ms   "
"m    "
"i    "
"n    "
"g    "

{(-#x)$x@&~^x} स्ट्रिंग से किसी भी स्थान को हटा देगा और फिर स्ट्रिंग को उसकी मूल लंबाई से पैड कर देगा

k){(-#x)$x@&~^x}"a  b  c   de  f"
"         abcdef"

प्रत्येक ट्रांसपोज़्ड स्ट्रिंग्स में उस फ़ंक्शन को लागू करें, फिर परिणाम प्राप्त करने के लिए आउटपुट को फ्लिप करें

k){+{(-#x)$x@&~^x}'+x@\:!|/#:'x}("Programming";"Puzzles";,"&";"Code";"Golf")
"P          "
"Prog       "
"&uzz       "
"Coderam    "
"Golflesming"

Comments

{+{(-#x)$x@&~^x}'+(|/#:'x)$x}29 के लिए।

— स्ट्रीटस्टर

Answer 19

पीबी - 310 बाइट्स

^w[B!0]{w[B=32]{vb[1]^b[0]}>}b[1]vb[1]>b[2]<[X]w[B!2]{t[T+B]b[0]>}b[0]v[T]w[X!-1]{b[1]<}b[1]vb[1]w[B!0]{w[B!0]{^w[B!0]{>}<<<<^[Y+1]w[B!0]{<}>t[B]b[0]w[B!1]{v}v<[X]w[B!0]{>}b[T]}b[0]vb[1]^w[X!0]{<vb[1]^t[B]b[0]^w[B!0]{^}b[T]w[B!0]{v}}vw[B!0]{^^w[B!0]{>}<b[0]vvw[B=0]{<}b[0]<[X]}^^>w[B=0]{vb[1]}v<<}>>^b[0]^<b[0]

क्या आपदा। मुझे मुश्किल से कुछ भी याद है कि यह कैसे काम करता है।

जिस तरह से pb का इनपुट काम करता है (एक ही बार में एक ही लाइन), आपको इनपुट में newlines के बजाय रिक्त स्थान का उपयोग करना होगा। यदि दुभाषिया कूड़ा नहीं था और आप इनपुट में नए सिरे शामिल कर सकते हैं, [B=32]तो शुरुआत में ही एकमात्र बदलाव होगा[B=10] ।

मैं pbi (दुभाषिया) के लिए एक अद्यतन पर काम कर रहा हूँ, जो यदि आप प्रोग्राम को देखना चाहते हैं, तो विज़ुअल्स को साफ़ कर देंगे। इसके लिए अभी भी बहुत काम करने की ज़रूरत है लेकिन इस समय में, आप इस कार्यक्रम को YouTube पर देख सकते हैं ।

Answer 20

जे, 17 बाइट्स

-.&' '"1&.(|:@|.)

काफी सुखद समाधान।

स्पष्टीकरण:

-.&' '"1&.(|:@|.)  input: list of strings y
              |.   reverse lines
           |:@     then transpose
-.&' '"1           remove blanks from columns
        &.         and undo the inside
           |:@|.   (that is, transpose and reverse again.)

टेस्ट केस समझाया

   s
Programming
Puzzles
&
Code
Golf
   |.s
Golf
Code
&
Puzzles
Programming
   |:|.s
GC&PP
oo ur
ld zo
fe zg
   lr
   ea
   sm
    m
    i
    n
    g
   -.&' '"1|:|.s
GC&PP
oour
ldzo
fezg
lr
ea
sm
m
i
n
g
   |.-.&' '"1|:|.s
g
n
i
m
sm
ea
lr
fezg
ldzo
oour
GC&PP
   |.|:-.&' '"1|:|.s
P
Prog
&uzz
Coderam
Golflesming
   (-.&' '"1)&.(|:@|.)s
P
Prog
&uzz
Coderam
Golflesming
   -.&' '"1&.(|:@|.)s
P
Prog
&uzz
Coderam
Golflesming

परीक्षण के मामलों

   f =: -.&' '"1&.(|:@|.)
   f
-.&' '"1&.(|:@|.)
   f >'Programming';'Puzzles';'&';'Code';'Golf'
P
Prog
&uzz
Coderam
Golflesming
   g =: [: > [: <;._1 '|'&,
   g 'Programming|Puzzles|&|Code|Golf'
Programming
Puzzles
&
Code
Golf
   f g 'Programming|Puzzles|&|Code|Golf'
P
Prog
&uzz
Coderam
Golflesming
   F =: f @ g
   F &. > 'Programming|Puzzles|&|Code|Golf' ; '1|23|456|7890' ; '1234|567|89|0'
+-----------+----+----+
|P          |1   |1   |
|Prog       |23  |52  |
|&uzz       |456 |863 |
|Coderam    |7890|0974|
|Golflesming|    |    |
+-----------+----+----+

Comments

;@;:&.(|:@|.)13 के लिए

— FrownyFrog

Answer 21

दरअसल , 13 बाइट्स

यह डेनिस के जेली उत्तर में वर्णित एल्गोरिथ्म का उपयोग करता है । इनपुट और आउटपुट दोनों स्ट्रिंग्स की सूची है। दुर्भाग्य से, अंतर्निहित सूची फ़ंक्शन बहुत अच्छी तरह से काम नहीं करता है यदि आंतरिक सूचियां या तार सभी समान लंबाई नहीं हैं, जो पहले स्थान पर लंबवत रूप से ढहने के बिंदु को पराजित करेगा। गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

R2`;i(lZ♂Σ`nR

Ungolfing

          Implicit input s.
R         Reverse s.
2`...`n   Run the following function twice.
  ;i        Duplicate and flatten onto the stack.
  (l        Get the number of strings in the list.
  Z         Zip len strings together, which results in a list of lists of characters.
  ♂Σ        Sum each list of characters, which essentially joins them together.
           This function essentially transposes
R         Reverse the result.
          Implicit return.

Answer 22

रैकेट 312 बाइट्स

(let((lr list-ref)(ls list-set)(sl string-length)(ss substring)(l(string-split s)))(let p((ch #f))
(for((i(-(length l)1)))(define s(lr l i))(define r(lr l(+ 1 i)))(define n(sl s))(define m(sl r))
(when(> n m)(set! l(ls l i(ss s 0 m)))(set! l(ls l(+ 1 i)(string-append r(ss s m n))))(set! ch #t)))(if ch(p #f)l)))

Ungolfed:

(define (f s)
  (let ((lr list-ref)
        (ls list-set)
        (sl string-length)
        (ss substring)
        (l (string-split s)))
    (let loop ((changed #f))
      (for ((i (sub1 (length l))))
        (define s (lr l i))
        (define r (lr l (add1 i)))
        (define n (sl s))
        (define m (sl r))
        (when (> n m)
          (set! l (ls l i (ss s 0 m)))
          (set! l (ls l (add1 i)(string-append r (ss s m n))))
          (set! changed #t)))
      (if changed (loop #f)
          l))))

परिक्षण:

(f "Programming Puzzles & Code Golf")

आउटपुट:

'("P" "Prog" "&uzz" "Coderam" "Golflesming")

Answer 23

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

v=>(v=v.split`
`).map(_=>v=v.map((x,i)=>v[++i]?x.slice(0,n=v[i].length,v[i]+=x.slice(n)):x))&&v.join`
`

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

इनर मैप पहले चेक करता है कि क्या अगली लाइन है, यदि ऐसा है, और यह छोटा है, तो ओवरफ्लो को अगली लाइन पर छोड़ें। यदि पहली पंक्ति में "ABCD" है और दूसरी पंक्ति में "FG" है, तो "CD" को पहली पंक्ति से दूसरी पंक्ति में छोड़ें ताकि पहली पंक्ति "AB" बन जाए और दूसरी "FGCD" बन जाए।

जैसा कि हम ऐसा करते हैं, जितनी बार लाइनें होती हैं, उतने ही अक्षर गिरते हैं, जितने वांछित परिणाम के साथ हमें छोड़ते हैं।

Answer 24

जाप , 8 बाइट्स

y kS ù y

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

यह काम किस प्रकार करता है

Uy kS ù y

Uy  Transpose at newline
kS  Replace spaces with nothing
ù   Left-pad to fit the longest line
y   Transpose at newline

ऐसा भी है zजो 2D स्ट्रिंग को 90 डिग्री के गुणक से घुमाता है, लेकिन यह किसी तरह स्ट्रिंग को छोटा कर देता है height > length।

Comments

7 बाइट्स । Japt में आपका स्वागत है, वैसे (अगर मैंने आपका पहले से स्वागत नहीं किया है)।

— झबरा

Answer 25

05AB1E , 10 9 बाइट्स

¶¡RζðмζR»

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

या वैकल्पिक शुरुआत के साथ:

.BRøðмζR»

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

@ डेनिस Py ’पाइथ जवाब के समान दृष्टिकोण ।
-1 बाइट के साथ @Eignign की बदौलत ।ðõ:ðм

स्पष्टीकरण:

¶¡       # Split on new-lines
  R      # Reverse the list
   ζ     # Zip/Transpose with unequal-length items (with space filler by default)
ðм       # Remove all spaces
  ζ      # Zip/Transpose unequal-length items (with space filler) again
   R     # Reverse the list again
    »    # Join the list by newlines, and output implicitly

वैकल्पिक विवरण:

.B      # Box (implicitly splits on new-lines and appends spaces)
   ø    # Zip/Transpose with equal-length items
        # Rest is the same

Answer 26

आर, s81 52 बाइट्स

function(x)apply(x,2,function(.).[order(!is.na(.))])

#old,longer version did the same but less efficiently
#function(x)apply(x,2,function(x){n<-na.omit(x);c(rep("",length(x)-length(n)),n)}))

मैंने प्रश्न की व्याख्या करने में कुछ स्वतंत्रता ली और यह माना कि पाठ मैट्रिक्स में प्रति सेल एक वर्ण के साथ प्रदर्शित होता है, इस प्रकार:

x <- as.matrix(read.fwf(textConnection("Programming
Puzzles
&
Code
Golf"), widths=rep(1, 11)))

तो x बन जाता है:

     V1  V2  V3  V4  V5  V6  V7  V8  V9  V10 V11
[1,] "P" "r" "o" "g" "r" "a" "m" "m" "i" "n" "g"
[2,] "P" "u" "z" "z" "l" "e" "s" NA  NA  NA  NA 
[3,] "&" NA  NA  NA  NA  NA  NA  NA  NA  NA  NA 
[4,] "C" "o" "d" "e" NA  NA  NA  NA  NA  NA  NA 
[5,] "G" "o" "l" "f" NA  NA  NA  NA  NA  NA  NA 

अब मैं उपयोग करता हूं orderऔर [कॉलम को छाँटना चाहता हूं ताकि NA पहले आए और फिर अन्य सभी मान:

     V1  V2  V3  V4  V5  V6  V7  V8  V9  V10 V11
[1,] "P" NA  NA  NA  NA  NA  NA  NA  NA  NA  NA 
[2,] "P" "r" "o" "g" NA  NA  NA  NA  NA  NA  NA 
[3,] "&" "u" "z" "z" NA  NA  NA  NA  NA  NA  NA 
[4,] "C" "o" "d" "e" "r" "a" "m" NA  NA  NA  NA 
[5,] "G" "o" "l" "f" "l" "e" "s" "m" "i" "n" "g"

यह लंबे समय तक हो जाता है यदि यह आवश्यक हो कि आउटपुट शब्द हो:

s <- (function(x)apply(x,2,function(.).[order(!is.na(.))]))(x)
s[is.na(s)]<-""
apply(s, 1, paste, collapse="")
# [1] "P"           "Prog"        "&uzz"        "Coderam"     "Golflesming"

Comments

PPCG में आपका स्वागत है (पीछे)! जब तक ओपी आपके प्रारूप के साथ ठीक है, तब तक आप सुरक्षित हैं! सामान्य तरीका यह है कि आप इसे प्रश्न के लिए टिप्पणी में पूछें।

— JayCe

जैसा कि एक अन्य प्रश्न के आपके उत्तर में उल्लेख किया गया है, उत्तर पूर्ण ईंधन या कार्यक्रमों की function(x)आवश्यकता है ताकि बाइट की गिनती में शामिल किया जा सके।

— JayCe

Answer 27

आर, 196 189 170 बाइट्स

function(x){l=nchar;o=function(y)which(diff(l(y))<0)[1];d=function(x,i)"[<-"(x,i:(j<-i+1),c(a<-substr(x[i],1,l(x[j])),sub(a,x[j],x[i])));while(!is.na(o(x)))x=d(x,o(x));x}

एक मानव पठनीय संस्करण:

f<-function(x){
  l=nchar;

  # find the first line in x that is longer than the next line
  # if no such line exists o(x) will be NA
  o = function(y) which(diff(l(y))<0)[1]

  # d(x,i) --> clips the line i in x, adding the remainder to x[i+1]
  d = function(x,i) "[<-"(x,i:(j<-i+1),
        c(a<-substr(x[i],1,l(x[j])), sub(a,x[j],x[i])))
         # a --> clipped x[i],      sub(a,x[j],x[i]) --> expanded x[j]

  while(!is.na(o(x)))x=d(x,o(x));x
}                            

यह काम किस प्रकार करता है:

1. पहली "खराब" लाइन लें, अर्थात, जो लाइन अगली लाइन से लंबी है, "अतिरिक्त" भाग लें और इसे अगली पंक्ति में जोड़ें
2. जांचें कि क्या कोई "खराब" रेखाएं बची हैं, यदि हां # 1 पर जाएं

(या दूसरे शब्दों में, "शानदार" भाग तब तक नीचे गिर जाते हैं जब तक कि सब कुछ नीचे गिर सकता है।)

इनपुट: एक चरित्र वेक्टर।

x<-readLines(textConnection("Programming\nPuzzles\n&\nCode\nGolf"))
f(x)
# [1] "P"           "Prog"        "&uzz"        "Coderam"     "Golflesming"

Answer 28

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

l=length
g(z,i)=(n=z[i];m=z[i+1];(N,M)=l.([n,m]);z[i:i+1]=[n[1:min(N,M)],m*n[M+1:N]])
f(s,w=split(s),d=1:l(w)-1)=(g.([w],[d d]);join(w,"\n"))

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

के साथ प्रसारण g.([w], [d d])मुझे किसी भी मानचित्र विवरण से छुटकारा पाने की अनुमति देता है और मुझे लगभग 7 बाइट्स बचाता है।