काम

यह चुनौती बहुत सरल है। आपका इनपुट पूर्णांक का एक आयताकार 2D सरणी है, जिसका आकार कम से कम 1 × 1 है। इसे किसी भी उचित प्रारूप में लिया जा सकता है। आपका आउटपुट इनपुट सरणी होगा, लेकिन सभी प्रविष्टियों के साथ नहीं पहले या अंतिम पंक्ति या स्तंभ के लिए सेट पर 0। यह इनपुट के समान प्रारूप में होना चाहिए।

उदाहरण के लिए, यदि इनपुट ऐरे है

67  4 -8  5 13
 9 13 42  4 -7
 1  1  3 -9 29
16 99  8 77  0

फिर सही आउटपुट है

67  4 -8  5 13
 9  0  0  0 -7
 1  0  0  0 29
16 99  8 77  0

नियम और स्कोरिंग

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

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

कॉपी-पेस्टिंग को आसान बनाने के लिए इन्हें नेस्टेड सूचियों के रूप में स्वरूपित किया जाता है।

[[3]] -> [[3]]
[[7,2,8]] -> [[7,2,8]]
[[3],[5],[12],[-6]] -> [[3],[5],[12],[-6]]
[[99,98,97],[88,87,86]] -> [[99,98,97],[88,87,86]]
[[6,7],[8,9],[10,11]] -> [[6,7],[8,9],[10,11]]
[[-1,-2,-3],[1,2,3],[5,5,5]] -> [[-1,-2,-3],[1,0,3],[5,5,5]]
[[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] -> [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]]
[[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] -> [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]]

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है। यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

यदि आप कई संख्याओं को शामिल करना चाहते हैं (उदाहरण के लिए, क्योंकि आपने अपना स्कोर बेहतर कर लिया है या आप दुभाषिया झंडों को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि शीर्षक में वास्तविक अंक अंतिम संख्या है:

## Perl, <s>50</s> 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो लीडरबोर्ड स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

var QUESTION_ID=71591,OVERRIDE_USER=32014;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Expand snippet

code-golf array-manipulation

— Zgarb
स्रोत

13

MATL , 9 बाइट्स

0HJ_ht4$(

इनपुट प्रारूप में है

[67  4 -8  5 13;  9 13 42  4 -7;  1  1  3 -9 29; 16 99  8 77  0]

EDIT (12 जून, 2016): भाषा में परिवर्तन के अनुकूल होने के लिए, नीचे दिए गए लिंक को _बदल दिया गया हैq ।

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

0           % Push a 0: value that will be assigned into the array
HJ_h        % Vector [2, -1j]: this corresponds to index 2:end-1 for rows
t           % Duplicate: same index for columns
4$(         % Assignment indexing with 4 inputs: array, new value, row and col indices
            % Since the first input (array) to this function is currently missing, it's
            % implicitly taken at this point from stdin
            % Implicitly display stack contents, which is the modified array

— लुइस मेंडो
स्रोत

2

अच्छा! मुझे पता था कि MATL रनिंग में होगा। : D

— बीकर

12

जावा 7, एक पूरी तरह से नामित फ़ंक्शन के रूप में: 85

void f(int[][]a){for(int i=0,j;++i<a.length-1;)for(j=1;j<a[i].length-1;)a[i][j++]=0;}

आप कुछ बाइट्स को हटाने के लिए जावा 8 में इसे लेम्बडा कर सकते हैं, लेकिन मैं वास्तव में ऐसा नहीं करता।

— Geobits
स्रोत

आप का उपयोग करके अंतरिक्ष बचा सकता है Arrays.fill(a[i],1,a[i].length-1,0);? यह 37 के बजाय केवल 36 बाइट्स है। =)

— corsiKa

@ corsiKa यह अच्छा होगा, लेकिन मुझे इसे आयात करना होगा या इसे पूरी तरह से योग्य बनाना होगा: /

— जियोबिट्स

बस जिज्ञासा से बाहर, तुम दोनों छोरों अलग क्यों है? क्यों नहीं for(int i=0,j;++i<a.length-1;)for(j=0;++j<a[i].length-1;)a[i][j]=0;? यह किसी भी बाइट को नहीं बचाता है, लेकिन यह दोनों छोरों के समान होने के साथ अधिक सुसंगत है। :)

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

12

जेली, 18 17 15 9 बाइट्स

0W&ṖZ
ÇÇ^

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

पृष्ठभूमि

यह दृष्टिकोण @ Sp3000 के जेली उत्तर पर आधारित है , विशेष रूप से विभिन्न लंबाई की सूचियों के बीच वेक्टरकृत संचालन का लाभ उठाने के लिए उनके विचार पर।

हम इनपुट की पहली पंक्ति में बिटवाइंड और 0 और प्रत्येक पूर्णांक लेकर शुरू करते हैं। स्वचालित वैश्वीकरण के कारण, यह बिटवाइंड और [0] और इसकी अंतिम पंक्ति के बिना इनपुट को प्राप्त करके प्राप्त किया जा सकता है । 0 को पहली पंक्ति के साथ जोड़ा गया है, जिसके परिणामस्वरूप शून्य की एक पंक्ति है। चूंकि शेष पंक्तियों का [0] में कोई समकक्ष नहीं है , वे अछूते रह गए हैं।

अब हम परिणाम को स्थानांतरित करते हैं, उपरोक्त परिवर्तन को एक बार फिर से लागू करते हैं (प्रभावी रूप से अंतिम कॉलम को हटाकर पहले को शून्य करते हैं), और फिर से स्थानांतरित करें।

इनपुट के लिए

 67   4  -8   5  13
  9  13  42   4  -7
  1   1   3  -9  29
 16  99   8  77   0

इसका परिणाम यह होगा

  0   0   0   0
  0  13  42   4
  0   1   3  -9

अब, हम इस परिणाम और मूल मैट्रिक्स के बिट वाइज XOR लेते हैं। एक पूर्णांक को XOR करने से 0 की उपज प्राप्त होती है । किसी पूर्णांक को XOR करने से 0 (या इसे बिल्कुल नहीं XORing) करने से एक ही पूर्णांक प्राप्त होता है। यह मैट्रिक्स को खोखला कर देता है।

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

0W&ṖZ    Helper link. Argument: M (matrix)

0W       Yield [0].
   Ṗ     Yield M, without its last row.
  &      Take the bitwise AND of both.
    Z    Zip the result.

ÇÇ^      Main link. Input: A (matrix)

Ç        Call the helper link on A.
 Ç       Call the helper link on the result.
  ^      Take the bitwise XOR of the result and A.

— डेनिस
स्रोत

8

गणितज्ञ, 27 बाइट्स

(a=#;a[[2;;-2,2;;-2]]=0;a)&

— alephalpha
स्रोत

2

प्रभावशाली। अब, क्या आप इसे स्पष्ट करेंगे? ऐसा लगता है कि आप आंतरिक कोशिकाओं को फिर से शून्य पर असाइन कर रहे हैं और -2एस दूसरे-अंतिम कॉलम या पंक्ति को दर्शाता है।

— डेविड एफएक्स

यह कितना सरल है!

— njpipeorgan

7

आर , 33 48 बाइट्स

मुझे पता है, आर गोल्फिंग के लिए नहीं बना है। लेकिन यह स्थितीय अनुक्रमण के लिए बना है ... एक उदाहरण को लोड करना;

a <- matrix(c(67,4,-8,5,13,9,13,42,4,-7,1,1,3,-9,29,16,99,8,77,0), ncol=5, byrow=TRUE)
a
#      [,1] [,2] [,3] [,4] [,5]
# [1,]   67    4   -8    5   13
# [2,]    9   13   42    4   -7
# [3,]    1    1    3   -9   29
# [4,]   16   99    8   77    0

किसी भी स्थिति में किनारे या स्तंभ पर मान को 0 से बदलें:

x <- function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]<-0;a}

x(a)
#      [,1] [,2] [,3] [,4] [,5]
# [1,]   67    4   -8    5   13
# [2,]    9    0    0    0   -7
# [3,]    1    0    0    0   29
# [4,]   16   99    8   77    0

2-कॉलम परीक्षण की भी जाँच करें:

b <- matrix(c(99,98,97,88,87,86), ncol=2, byrow=TRUE)
b
#     [,1] [,2]
#[1,]   99   98
#[2,]   97   88
#[3,]   87   86

x(b)
#     [,1] [,2]
#[1,]   99   98
#[2,]   97   88
#[3,]   87   86

पश्चात: पिछला प्रयास

# a[2:(nrow(a)-1),2:(ncol(a)-1)]<-0 # previous attempt

सभी उदाहरणों का परीक्षण:

tests <- read.table(text="[[3]] -> [[3]]
                          [[7,2,8]] -> [[7,2,8]]
                          [[3],[5],[12],[-6]] -> [[3],[5],[12],[-6]]
                          [[99,98,97],[88,87,86]] -> [[99,98,97],[88,87,86]]
                          [[6,7],[8,9],[10,11]] -> [[6,7],[8,9],[10,11]]
                          [[-1,-2,-3],[1,2,3],[5,5,5]] -> [[-1,-2,-3],[1,0,3],[5,5,5]]
                          [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] -> [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]]
                          [[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] -> [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]]")
tests$cols <- c(1,3,1,3,2,3,5,5)
tests$V1 <- gsub("\\[|\\]","",tests$V1)
tests$V1 <- paste0("c(",tests$V1,")")
tests$V3 <- gsub("\\[|\\]","",tests$V3)
tests$V3 <- paste0("c(",tests$V3,")")

testfn <- function(testno) {
  intest <- matrix(eval(parse(text=tests$V1[testno])), ncol=tests$cols[testno], byrow=TRUE)
  intest <- x(intest)
  outtest <- matrix(eval(parse(text=tests$V3[testno])), ncol=tests$cols[testno], byrow=TRUE)
  return(identical(intest, outtest))
}

sapply(seq_len(nrow(tests)), testfn)
# [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE

— जोनाथन कैरोल
स्रोत

1 या 2 पंक्ति या स्तंभ मैट्रिक्स के साथ क्या होता है?

— मेल

अच्छा बिंदु, पहला प्रयास 2-स्तंभ परीक्षण को विफल करता है और मध्य पंक्ति को हटा देता है। मैं अपडेट करूंगा।

— जोनाथन कैरोल

1

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! हमें सभी कार्यक्रमों या कार्यों को पूरा करने की आवश्यकता है। इस स्थिति में, आपका स्कोर कोड केवल एक स्निपेट है, क्योंकि यह मानता है कि चर aमौजूद है। हमारे नियमों के अनुपालन में होने के लिए, आप इसे एक फ़ंक्शन बना सकते हैं जो कि मैट्रिक्स लेता है, जैसे function(a){a[-c(1,nrow(a)),-c(1,ncol(a))]=0;a}कि 47 बाइट्स।

— एलेक्स ए।

6

गणितज्ञ 81 76 बाइट्स

(d=Dimensions@m;q=MemberQ;m Boole@Array[{1,d[[1]]}~q~#||{1,d[[2]]}~q~#2&,d])&

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

मान लें कि इनपुट सरणी में संग्रहीत है m। के आयाम mहैं {4,5} `

(m={{67,4,-8,5,13}, {9,13,42,4,-7}, {1,1,3,-9,29}, {16,99,8,77,0}})//MatrixForm

निम्नलिखित सरणी में प्रत्येक सेल a, सही है यदि सेल या तो पहली ||पंक्ति में है ( ) अंतिम पंक्ति में या पहले या अंतिम कॉलम में; अन्यथा यह गलत है।

(d=Dimensions@m;a=Array[MemberQ[{1,d[[1]]},#]||MemberQ[{1,d[[2]]},#2]&,d])&[m]//MatrixForm

फ़ंक्शन Booleको सरणी में लागू करना True को 1 में परिवर्तित करता है और गलत को 0 पर।

b = Boole[a]

मैट्रिक्स mको गुणा करें b। यह बी में संबंधित सेल द्वारा मीटर में प्रत्येक कोशिका को गुणा करता है।

m b

— DavidC
स्रोत

आप ||अपने OR के रूप में बाइट्स के एक जोड़े को बचाने के लिए उपयोग कर सकते हैं , और मैं कुछ अन्य बाइट्स देख सकता हूं जिन्हें आप भी सहेज सकते हैं!

— एक सीमन्स

एक सीमन्स, सुझाव के लिए धन्यवाद।

— 21

# -उपयोग को @ ArrayFilter [Det, Array [Norm @ * List, Dimensions @ #], 1] # &

— njpipeorgan

@njpipeorgan, मेरा सुझाव है कि आप इसे सबमिट करें। (और उम्मीद है कि यह कैसे काम करता है समझा!)

— डेविड एफसी

@ डेविड मैंने अपना उत्तर

— njpipeorgan

6

जीएनयू सैड, 31

4 बाइट बचाने के लिए @manatwork का धन्यवाद।

संस्करण 4.2.2 या इससे पहले, इस प्रतिबद्ध (चर्चा) से पहले ।

-rविकल्प के लिए स्कोर में +1 शामिल है ।

इनपुट पंक्तियाँ अलग की गई हैं। प्रत्येक पंक्ति के तत्व एकल-पंक्ति से अलग होते हैं।

1n
$n
:
s/ -?\w+ / : /
t
y/:/0/

व्याख्या

1n                   # 1st line: print unchanged, then load next line
$n                   # last line: print unchanged, then load next line (i.e. EOF and stop)
:                    # unnamed label
s/ -?\w+ / : /       # substitute a number in spaces with a `:` in spaces
t                    # If the above matched, jump back to the label and try again
y/:/0/;              # transliterate `:` to `0`

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

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

1

ओह, मैं देख रहा हूँ, यह "फैंसी" तरीका है बिना किसी लुक के, और धन्यवाद!

— andlrc

1

बहुत सारे ब्रेसिज़ 1n;$n;:;s/ -?\w+ / : /;t;y/:/0/:।

— मैनटवर्क

1

क्या आप उस प्रश्न के बारे में जानकारी शामिल कर सकते हैं जो आपके उत्तर को एक ब्लॉक ब्लॉक में काम करता है, साइट वास्तव में धीमी है और पूरी तरह से लोड होने में 1 मिनट का समय लगता है

— फेरीबग

@manatwork धन्यवाद - 4 बाइट्स बचाए गए!

— डिजिटल ट्रामा

@Ferrybig ने इस विषय पर देव चर्चा में एक और कड़ी जोड़ दी ।

— डिजिटल ट्रामा

5

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

function h(M) M(2:end-1,2:end-1)=0

ध्यान दें कि इनपुट के लिए सरणी पंक्तियों को अलग करने के लिए अर्धविराम की आवश्यकता होती है:

h([[3];[5];[12];[-6]])

स्पष्टीकरण:

ऑक्टेव (और MATLAB) सरणी सूचकांक 1-आधारित हैं। श्रेणी को निर्दिष्ट करने से Array(1:end)आपको (इस उदाहरण में एक-आयामी) सरणी के सभी तत्व मिलेंगे। Array(2:end-1)आपको पहले और अंतिम को छोड़कर सभी तत्वों को देगा ।

M(2:end-1,2:end-1)=0

0पहली या अंतिम पंक्ति या कॉलम में सभी तत्वों के लिए सेट :

>> A = [[-1,-2,-3];[1,2,3];[5,5,5]]
A =

  -1  -2  -3
   1   2   3
   5   5   5

>> h(A)
M =

  -1  -2  -3
   1   0   3
   5   5   5

यदि आयामों में से एक से भी कम है या 2 के बराबर, रेंज end-1है कम 2 से, इसलिए सीमा की समाप्ति के (2:end-1)शुरुआत से कम है। इस मामले में, ऑक्टेव रेंज की उपेक्षा करता है और कुछ भी नहीं करता है। यह forलूप के अनुरूप है :

for (int i=2; i < 2; i++) {...}

पहले पुनरावृत्ति पर स्टॉप की स्थिति सही है, इसलिए हम लूप से बाहर आते हैं।

>> A = [[6,7];[8,9];[10,11]]
A =

    6    7
    8    9
   10   11

>> h(A)
M =

    6    7
    8    9
   10   11

— बीकर
स्रोत

5

जेली , १२ बाइट्स

ZṖṖ1;¥€
¬ÇÇ×

मुझे लगता है कि यह काम करता है, फिर भी जेली के चारों ओर अपना सिर लपेटता है। इसे ऑनलाइन आज़माएं!

(-2 बाइट्स के लिए @ डेनिस का धन्यवाद)

1 और 0s के एरे द्वारा इनपुट ऐरे को गुणा करके प्रत्येक आयाम को छोटा करने का काम करता है। उदाहरण के लिए, [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]]हमारे द्वारा तत्व-वार को गुणा किया जाता है

1 1 1 1
1 0 0 0
1 0 0 0

पूरी व्याख्या

[Helper link - argument is a matrix]
Z           Zip
 ṖṖ         Pop last two elements, or [:-2]
   1;¥€     Append a 1 in front of every row

[Main link]
¬           Not, turning 0s to 1s and everything else to 0s. Even though some zeroes
            turn into 1s, it's fine because we multiply element-wise at the end,
            and 0*1 = 0
 ÇÇ         Perform helper link twice
   ×        Multiply element-wise

— Sp3000
स्रोत

5

ईएस 6, 52 48 46 बाइट्स

f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)

संपादित करें: @ user81655 के लिए 4 बाइट्स सहेजे गए। @ETHproductions की बदौलत एक और 2 बाइट्स बचाए।

— नील
स्रोत

चतुर! यहाँ एक बहुत समान दृष्टिकोण है gजिसके बिना कुछ बाइट्स बचाता है:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)

— user81655

अच्छी नौकरी! मैं 48 बाइट्स गिनता हूं (शायद आप गिनती करना भूल गए हैं f=), लेकिन आप इसे 46 तक नीचे f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)

— ला

1

@ETHproductions हाँ, मैं गिनती करना भूल गया f=। इसके अलावा, मैं थोड़ा आश्चर्यचकित +.5काम करता हूं, लेकिन मुझे लगता है कि यह दूसरे कॉल में एक स्ट्रिंग जोड़ देता है।

— नील

4

जावास्क्रिप्ट, 62 59 56 बाइट्स

s=>s.replace(/(^.*|\n\s*\S+)|\S+(?= .*\n)/g,(a,b)=>b||0)

यह दृष्टिकोण तर्क के रूप में एक स्ट्रिंग की अपेक्षा करता है। आप देख सकते हैं कि रेगेक्स यहाँ क्या करता है: https://regex101.com/r/kC6xA8/3

— हटा दिया
स्रोत

4

गणितज्ञ, 55 बाइट्स

#-Unitize@ArrayFilter[Det,Power~Array~Dimensions@#,1]#&

परीक्षण का मामला

%[RandomInteger[9,{5,5}]]
(*
  {{8,8,3,6,5},
   {7,0,0,0,4},
   {2,0,0,0,7},
   {3,0,0,0,5},
   {8,6,1,0,8}}
*)

व्याख्या

इस उत्तर का मुख्य विचार डेविडसी के उत्तर के समान है (पहले मास्क मैट्रिक्स का निर्माण करें, और फिर इसे मूल मैट्रिक्स में गुणा करें), लेकिन मास्क मैट्रिक्स का निर्माण अलग है।

ArrayFilter[f,list,r]के एक दायरे के भीतर fहर तत्व पर नक्शे ।listr

ArrayFilter[f,{1,2,3,4,5},1]
(* { f[{1,1,2}], f[{1,2,3}], f[{2,3,4}], f[{3,4,5}], f[{4,5,5}] } *)

ध्यान दें कि सीमा के तत्वों को डुप्लिकेट किया गया है जहां अपर्याप्त पड़ोसी हैं। जब list2-आयाम होते हैं, तो यह सुविधा Detवांछित परिणाम देने के लिए एक साथ काम करती है , क्योंकि डुप्लिकेट किए गए कॉलम या पंक्तियाँ चार सीमाओं पर निर्धारक को गायब कर देती हैं।

ArrayFilter[Det,Power~Array~{4,4},1]
(*
  {{0, 0,  0,    0},
   {0, 12, 72,   0},
   {0, 48, 1152, 0},
   {0, 0,  0,    0}}
*)

जहां Power~Array~{4,4}आंतरिक पदों पर निर्धारकों को गैर-शून्य होने की गारंटी देता है। तथा

1-Unitize@%
(*
  {{1,1,1,1},
   {1,0,0,1},
   {1,0,0,1},
   {1,1,1,1}}
*)

मास्क मैट्रिक्स देता है।

— njpipeorgan
स्रोत

4

पायथन, 50 बाइट्स

def f(a):
 for l in a[1:-1]:l[1:-1]=[0]*(len(l)-2)

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

मैंने सीखा है कि एक सूची को एक नकारात्मक संख्या के परिणाम से गुणा करना एक खाली सूची है, जो उपरोक्त कोड को छोटे इनपुट पर काम करने की अनुमति देता है।

— mathmandan
स्रोत

4

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

A->A[2:size(A,1)-1,2:size(A,2)-1]=0

यह एक अनाम फ़ंक्शन है जो किसी सरणी को स्वीकार करता है और इसे जगह में संशोधित करता है। इसे कॉल करने के लिए, इसे किसी वैरिएबल पर असाइन करें।

यहाँ दृष्टिकोण काफी सरल है: मी इनपुट सरणी ए द्वारा एन के लिए , हम सभी i = 2, ... के लिए A _ij = 0 असाइन करते हैं । n -1 और j = 2, ..., m -1 के लिए श्रेणियों का निर्माण करते हैं। सूचकांकों के। श्रेणियाँ खाली हो सकती हैं, जैसे कि यदि n या m = 1, तो जिस स्थिति में कोई प्रतिस्थापन नहीं किया जाता है।

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

डेनिस की बदौलत 15 बाइट बचीं!

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

4

सी, 62 बाइट्स

y;f(a,b,c)int **a;{for(b--;b-->1;)for(y=1;y<c-1;)a[b][y++]=0;}

उम्मीद है कि पैरामीटर के रूप में सरणी लंबाई / चौड़ाई में लेना ठीक है। मैं लगभग थोड़ा-बहुत याद / bzero के साथ खेला, लेकिन sizeof(int)कोड के आकार में भारी वृद्धि से।

संपादित करें: 55 बाइट्स यदि हम नियमों को आगे बढ़ा सकते हैं और हमारे सरणी को वर्णों के रूप में संग्रहीत कर सकते हैं क्योंकि इनपुट केवल एक ही अंक है।

x;
#define f(a,b,c) for(x=1;x<b-1;)bzero(a[x++]+1,c-2);

संपादित करें: टिप के लिए धन्यवाद वाशिंगटन गाइड!

— हंसी मजाक करना
स्रोत

क्या आपने सचमुच में गुणा करने की कोशिश की sizeof(int)? आप 4इसके बजाय ...

— anatolyg

sizeof(int) != 4मेरी मशीन पर: पी

— जोश

मुझे यकीन है कि यह अभी भी एक-अंकों की संख्या है, जिसे आप उपयोग कर सकते हैं।

— अनातोली

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

— जोश

धन्यवाद! अब मुझे अलॉफ़ -->ऑपरेटर का उपयोग करने के लिए भी मिलता है ;)

— जोश

3

पर्ल 6 , 28 बाइट्स

{.[1..*-2]»[1..*-2] »=»0}

यह इनपुट को जगह में संशोधित करता है

प्रयोग

my @test-cases = (
  [[3],] => [[3],],
  [[7,2,8],] => [[7,2,8],],
  [[3],[5],[12],[-6]] => [[3],[5],[12],[-6]],
  [[99,98,97],[88,87,86]] => [[99,98,97],[88,87,86]],
  [[6,7],[8,9],[10,11]] => [[6,7],[8,9],[10,11]],
  [[ -1,-2,-3],[1,2,3],[5,5,5]] => [[ -1,-2,-3],[1,0,3],[5,5,5]],
  [[67,4,-8,5,13],[9,13,42,4,-7],[1,1,3,-9,29],[16,99,8,77,0]] => [[67,4,-8,5,13],[9,0,0,0,-7],[1,0,0,0,29],[16,99,8,77,0]],
  [[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0],[1,0,1,0,1],[0,1,0,1,0]] => [[0,1,0,1,0],[1,0,0,0,1],[0,0,0,0,0],[1,0,0,0,1],[0,1,0,1,0]],
);

use Test;
plan +@test-cases;

for @test-cases {
  my $k = .key;
  {.[1..*-2]»[1..*-2] »=»0}( $k ); # <==
  ok $k eqv .value
}

1..8
ok 1 - 
ok 2 - 
ok 3 - 
ok 4 - 
ok 5 - 
ok 6 - 
ok 7 - 
ok 8 -

— ब्रैड गिल्बर्ट b2gills
स्रोत

{.[1..*-2]»[1..*-2]X=0}2 बाइट्स बचाता है

— raiph

@raiph पिछले दो मामलों के लिए काम नहीं करता है

— ब्रैड गिल्बर्ट b2gills

3

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

Y=>Y.map((X,y)=>X.map((N,x)=>x*y&&X[x+1]+.5&&Y[y+1]?0:N))

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

यह समाधान इनपुट में प्रत्येक y-index yऔर x-index के माध्यम से मैप xकरता है और इन दो सूचकांकों के आधार पर इसे बाहर फेंकने या न करने का फैसला करता है। चार मामले हैं जिन्हें हमें रखने की आवश्यकता है:

x 0 है
y 0 है
x आंतरिक सरणी की लंबाई के बराबर, शून्य से 1
y बाहरी सरणी की लंबाई के बराबर, शून्य से 1

हम पहले दो का थोड़ा गुणा के साथ ध्यान रख सकते हैं: iff या तो x*yरिटर्न कर रहे हैं या 0, और एक सकारात्मक पूर्णांक अन्यथा। अब तीसरे के लिए: हम जाँच कर सकते हैं कि , लेकिन यह बहुत सारे बाइट्स लेता है। ऐसा करने का एक और तरीका यह है कि जाँच करें कि क्या आगे की वस्तु मिथ्या है , जो कि आपको तब मिलती है जब आप किसी गैर-मौजूद वस्तु तक पहुँचने का प्रयास करते हैं। हालाँकि, यह तब भी मेल खाता है यदि अगला आइटम है , इसलिए हम 0.5 जोड़ते हैं ताकि यह सुनिश्चित हो सके कि ऐसा नहीं होता है:0xyX.length>x+1undefined0

1 + 0.5 = 1.5 (truthy)
0 + 0.5 = 0.5 (truthy)
-1 + 0.5 = -0.5 (truthy)
undefined + 0.5 = NaN (falsy)

अंत में, चौथा बिंदु: चूंकि बाहरी सरणी के अंदर केवल सरणियाँ हैं, और कोई भी सरणी सत्य है, हम सिर्फ जांच कर सकते हैं Y[y+1]। अब ?0:N, हम इसे परिवर्तित करते हैं 0यदि उपरोक्त सभी सत्य हो गए हैं; Nअन्यथा। और बस!

— ETHproductions
स्रोत

3

रेटिना ,३१ २४ 22

(?<=¶.+ )\S+(?= .*¶)
0

रैंडम के लिए धन्यवाद 2 बाइट्स सहेजे गए

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

यह करने के लिए एक बेहतर तरीका है, क्योंकि यह सिर्फ एक बहुत ही बुनियादी बहु-पंक्ति प्रतिस्थापन है। अनिवार्य रूप से हम प्रत्येक संख्या को पाते हैं जो एक नई पंक्ति, कुछ वर्णों और एक स्थान से पहले होती है, और उसके तुरंत बाद एक स्थान और उसके बाद एक नई पंक्ति होती है। फिर इन नंबरों को बदल दिया जाता है 0।

यह कॉलम पैडिंग को संरक्षित नहीं करेगा, लेकिन मुझे नहीं लगता कि यह कोई समस्या है।

— FryAmTheEggman
स्रोत

3

जावा 8, एक लंबो फ़ंक्शन के रूप में: 82 83 95 चार्ट / बाइट्स

लम्बे हस्ताक्षर: int[][] -> (void)(यानी Consumer<int[][]>)

(a)->{int[]v={1,1};while(++v[0]<a.length){while(++v[1]<a[0].length)a[v[0]-1][v[1]-1]=0;v[1]=1}}

EDIT ने एक गलती की, मुझे लगा कि एक [x, y] xth रो और yth कॉल है। हालांकि यह स्पष्ट रूप से [x] [y] होना चाहिए!

EDIT I कोड का परीक्षण करना भूल गया, और मुझे लूप के अंदर हर बार शून्य सेट करने की आवश्यकता है, +12 बाइट्स। : /

— HyperNeutrino
स्रोत

3

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

k _[x]=[x]
k f(x:y)=x:(f<$>init y)++[last y]
f=k(k(\_->0))

विस्तारित

onInner :: (a -> a) -> [a] -> [a]
onInner _ [x]    = [x]
onInner f (x:xs) = x : map f (init xs) ++ [last xs]

hollowOut :: [[Int]] -> [[Int]]
hollowOut = 
   onInner       -- leave first and last line alone 
     (onInner    -- leave first and last entry per line 
       (const 0) -- replace entries by 0
     )

— जीटा
स्रोत

आप चालू करने के लिए सक्षम होना चाहिए ++[last y]में :(last y)या:last y

— HEGX64

@ HEGX64: नहीं, गलत प्रकार। x : map f (…)प्रकार के पहले से ही है [a], और last yप्रकार है a, जबकि (:) :: a -> [a] -> [a]। हास्केल तरह के बेकार में एक सूची के अंत में एक तत्व जोड़ना, क्योंकि वे सूचियां एकल-लिंक की गई आगे की सूची हैं।

— ज़ीटा

उफ़। मुझे पता था कि मुझे इसे पोस्ट करने से पहले खुद कोशिश करनी चाहिए थी :)

— HEGX64

1

आप बदल सकते हैं kएक इन्फ़िक्स ऑपरेटर में, मान लें #और तर्क फ्लिप एक बाइट को बचाने के लिए: [x]#_=..., (x:y)#f=..., f=(#(# \_->0))और आप अपने मुख्य कार्य, अर्थात् के नाम ड्रॉप कर सकते हैं f=एक और दो बाइट के लिए।

— nimi

2

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

Qjbm:dSttld0P.Qe.Q

व्याख्या

                   - autoassign Q=eval(input())
                   - autoassign .Q = map(eval, rest_of_input)
Q                  - imp_print(Q)
   m        P.Q    -  [V for d in .Q[:-1]]
      Sttld        -     range(1, len(d)-2+1)
    :d     0       -    assign_indexes(d, ^, 0)
 jb                - "\n".join(^)
               e.Q - imp_print(.Q[-1])

इनपुट सरणियों को नई सूचियों से अलग किया जाता है

इसे यहाँ आज़माएँ

— नीला
स्रोत

2

ग्रूवी, 70 बाइट्स

यह बहुत रचनात्मक नहीं है, लेकिन यह कम है!

g={a->for(i=1;i<a.size()-1;i++)for(j=1;j<a[i].size()-1;)a[i][j++]=0;a}

व्याख्या

एक arg के साथ बंद होना

g={a->

पहले और अंतिम तत्वों को लंघन, आंतरिक सरणी पर Iterate

for(i=1;i<a.size()-1;i++)

आंतरिक सरणी में मध्य आइटम पर इरेट करें

for(j=1;j<a[i].size()-1;)

तत्वों को सेट करें 0और वापस लौटेंa

a[i][j++]=0;a}

टेस्ट

assert g([[3]]) == [[3]]
assert g([[7, 2, 8]]) == [[7, 2, 8]]
assert g([[3], [5], [12], [-6]]) == [[3], [5], [12], [-6]]
assert g([[99, 98, 97], [88, 87, 86]]) == [[99, 98, 97], [88, 87, 86]]
assert g([[6, 7], [8, 9], [10, 11]]) == [[6, 7], [8, 9], [10, 11]]
assert g([[-1, -2, -3], [1, 2, 3], [5, 5, 5]]) == [[-1, -2, -3], [1, 0, 3], [5, 5, 5]]
assert g([[67, 4, -8, 5, 13], [9, 13, 42, 4, -7], [1, 1, 3, -9, 29], [16, 99, 8, 77, 0]]) == [[67, 4, -8, 5, 13], [9, 0, 0, 0, -7], [1, 0, 0, 0, 29], [16, 99, 8, 77, 0]]
assert g([[0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [0, 1, 0, 1, 0]]) == [[0, 1, 0, 1, 0], [1, 0, 0, 0, 1], [0, 0, 0, 0, 0], [1, 0, 0, 0, 1], [0, 1, 0, 1, 0]]

— जे एटकिन
स्रोत

2

आर, 71 64 57 बाइट्स

function(m){if(all((y<-dim(m)-1)>1))m[2:y[1],2:y[2]]=0;m}

संपादित -7 स्पष्ट रूप से <2-पंक्ति या <2-स्तंभ मैट्रिक्स स्पष्ट रूप से निपटने से बाइट्स EDIT2 मैट्रिक्स के आयामों बताए द्वारा -7 बाइट्स आकार की जाँच करते समय

— mnel
स्रोत

1

सी ++, 80 79 बाइट्स

int**दिए गए आकारों के साथ सरणी की अपेक्षा करता है nऔर k:

void p(int**c,int n,int k){for(int j,i=1;1+i<n;++i)for(j=1;j+1<k;)c[i][j++]=0;}

एक विकल्प जो किसी भी प्रकार के लिए काम करता है size()और value_type & operator[](int)(98 बाइट्स):

template<class C>void p(C&c){for(int j,i=1;1+i<c.size();++i)for(j=1;j+1<c[i].size();)c[i][j++]=0;}

विस्तारित संस्करण

template <class Container>
void hollowOut(Container & ctn){
    const auto size = ctn.size();

    for(typename Container::size_type i = 1; i + 1 < size; ++i) {
        const auto inner_size = ctn[i].size();

        for(decltype(inner_size) j = 1; j + 1 < inner_size; ++j) {
            ctn[i][j] = 0;
        }
    }
}

— जीटा
स्रोत

इनपुट में मैट्रिक्स के आयामों को जोड़ने जैसा लगता है एक मानक खामियों का

— सामना करना पड़ता है

1

PHP, 82 81 80 71 बाइट्स

function(&$z){for(;$z[++$i+1];)for(;0 .$z[0][++$$i+1];)$z[$i][$$i]=0;};

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

php -r '$f = function(&$z){for(;$z[++$i+1];)for(;0 .$z[0][++$$i+1];)$z[$i][$$i]=0;};   $z=[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]; $f($z); print_r($z);'

निरंतर आकार पंक्तियों को मानकर एक बाइट को सहेजा गया (thx to manatwork)
इसे एक अनाम फ़ंक्शन बनाकर एक बाइट को सहेजा गया
अगले सरणी आइटम की सत्यता का उपयोग करके 7 बाइट्स को बचाया, कॉल को रोकने के लिए count, जो कोडगोल्फ के लिए एक लंबा नाम है

— aross
स्रोत

मैट्रिक्स को संसाधित करते समय, सभी उप-सरणियों की लंबाई समान होनी चाहिए। तो आंतरिक forमें हमेशा count($z[0])-11 वर्ण को अलग करने के लिए पुनरावृति करना सुरक्षित है ।

— मैनटवर्क

1

एपीएल, 17 बाइट्स 15 बाइट्स

{⍵×(⌽∨⊖)1∊¨⍳⍴⍵}

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

⍳⍴⍵ एक 2 डी सरणी उत्पन्न करता है जहां सभी कोशिकाओं में तर्क के सभी कोशिकाओं के निर्देशांक होते हैं।
1∊¨यदि कोई 1 है तो ऐसी प्रत्येक सेल में खोज करता है और यदि ऐसा है, या अन्यथा 0 देता है। यह एक मैट्रिक्स बनाता है जहां पहली पंक्ति और पहला कॉलम 1 s हैं और बाकी सभी 0 हैं।
(⌽∨⊖) मैट्रिक्स के तार्किक "या" दो संस्करण के साथ संयोजन करता है, एक पहले के साथ उलटा होता है और एक अंतिम अक्ष के साथ उलटा होता है।
⍵× मानक गुणन है।

— lstefano
स्रोत

आप (with) के साथ (two), दो बाइट कम

— मोरिस ज़ुका

प्रतिभाशाली! मुझे ऐसा करने दो!

— लेस्टिफैनो

0

पर्ल, 34 + 2 = 36 बाइट्स

next if$.==1||eof;s/ .+?(?= )/ 0/g

की आवश्यकता है -pध्वज की :

$ perl -pE'next if$.==1||eof;s/ .+?(?= )/ 0/g' <<< $'1 2 3\n4 5 6\n7 8 9'
1 2 3
4 0 6
7 8 9

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

# '-p' Read each line into `$_` and auto prints
next if$.==1||eof; # `$.` is set to to the current line in file (1, 2, ..., n)
                   # and `eof` is true if its the last line
s/ .+?(?= )/ 0/g

— andlrc
स्रोत

0

लुआ, 69 बाइट्स

function f(a)for i=2,#a-1 do
for o=2,#a[i]-1 do
a[i][o]=0
end
end end

अगर केवल मैं डॉस और अंत के बजाय घुंघराले ब्रेसिज़ था ...

— गप्पी
स्रोत

0

SmileBASIC, 69 51 बाइट्स

DEF H A,W,H
FOR I=1TO H-2FILL A,0,W*I+1,W-2NEXT
END

एक सरणी में 2 डी क्षेत्र को भरना आमतौर पर लूप में फिल का उपयोग करने की आवश्यकता होगी। लेकिन ग्राफिक्स पेज पर 2 डी डेटा के साथ काम करना बहुत आसान है, इसलिए पहले सरणी को वहां कॉपी किया जाता है।

Aww मुझे लगा कि मैं ग्राफिक्स कमांड का उपयोग करके बहुत चालाक था ... लेकिन यह कहता है कि FILL का एक गुच्छा वास्तव में कम है।

वैसे भी, फंक्शन इनपुट सरणी और चौड़ाई / ऊंचाई हैं (यह स्माइलबेसिक में मानक है क्योंकि किसी ऐरे के आयाम को जांचने का कोई तरीका नहीं है।)

— 12Me21
स्रोत

0

APL (Dyalog Classic) , 12 बाइट्स

⊢-(⍉0⍪1↓⌽)⍣4

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

⍉⌽⍵ सामान्य रूप से घूमता है (क्षैतिज रूप से उल्टा और स्थानांतरित होता है)

यहां हम इसे एक साथ जोड़ते हैं 0⍪1↓⍵जिसमें पहली पंक्ति को शून्य के साथ बदल दिया जाता है (एक पंक्ति को छोड़ दें, फिर शीर्ष पर संक्षिप्त करें 0) एक ही ट्रेन में:⍉0⍪1↓⌽

⍣4 4 बार दोहराता है

⊢- मूल मैट्रिक्स से घटाता है

— NGN
स्रोत

किसी सरणी को खोखला कर देना

काम

नियम और स्कोरिंग

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

लीडरबोर्ड

MATL , 9 बाइट्स

जावा 7, एक पूरी तरह से नामित फ़ंक्शन के रूप में: 85

जेली, 18 17 15 9 बाइट्स

पृष्ठभूमि

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

गणितज्ञ, 27 बाइट्स

आर , 33 48 बाइट्स

गणितज्ञ 81 76 बाइट्स

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

जीएनयू सैड, 31

व्याख्या

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

स्पष्टीकरण:

जेली , १२ बाइट्स

पूरी व्याख्या

ईएस 6, 52 48 46 बाइट्स

जावास्क्रिप्ट, 62 59 56 बाइट्स

गणितज्ञ, 55 बाइट्स

पायथन, 50 बाइट्स

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

सी, 62 बाइट्स

पर्ल 6 , 28 बाइट्स

प्रयोग

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

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

रेटिना ,३१ २४ 22

जावा 8, एक लंबो फ़ंक्शन के रूप में: 82 83 95 चार्ट / बाइट्स

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

विस्तारित

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

ग्रूवी, 70 बाइट्स

व्याख्या

टेस्ट

आर, 71 64 57 बाइट्स

सी ++, 80 79 बाइट्स

विस्तारित संस्करण

PHP, 82 81 80 71 बाइट्स

एपीएल, 17 बाइट्स 15 बाइट्स

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

पर्ल, 34 + 2 = 36 बाइट्स

लुआ, 69 बाइट्स

SmileBASIC, 69 51 बाइट्स

APL (Dyalog Classic) , 12 बाइट्स