কাজটি

এই চ্যালেঞ্জ খুব সহজ। আপনার ইনপুটটি কমপক্ষে 1 2 1 আকারের পূর্ণসংখ্যার একটি আয়তক্ষেত্র 2D অ্যারে। এটি যে কোনও যুক্তিসঙ্গত বিন্যাসে নেওয়া যেতে পারে। আপনার আউটপুট ইনপুট অ্যারের হবে, কিন্তু সমস্ত এন্ট্রি সঙ্গে না প্রথম অথবা শেষ সারি বা কলাম সেটে 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

এমএটিএল , 9 বাইট

0HJ_ht4$(

ইনপুট ফর্ম্যাটে রয়েছে

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

সম্পাদনা (জুন 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

নিস! আমি জানতাম এমএটিএল চলবে। : ডি

— বেকার

12

জাভা 7, পুরো নামযুক্ত ফাংশন হিসাবে: 85 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 বাইট =)))

— কর্সিকা

@ করসিকা এটি দুর্দান্ত লাগবে তবে আমাকে এটি আমদানি করতে বা পুরোপুরি যোগ্যতা অর্জন করতে হবে: /

— জিওবিটস

কৌতূহলের বাইরে, আপনার উভয় লুপগুলি আলাদা কেন? কেন হবে না 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
ÇÇ^

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

পটভূমি

এই পন্থাটি @ স্প3000 এর জেলি উত্তরের উপর ভিত্তি করে বিশেষত বিভিন্ন দৈর্ঘ্যের তালিকার মধ্যে ভেক্টরাইজড অপারেশনগুলির সুবিধা নেওয়ার তার ধারণার ভিত্তিতে।

আমরা 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

এখন, আমরা এই ফলাফলটির বিটওয়াইজ এক্সওআর এবং মূল ম্যাট্রিক্স গ্রহণ করি। নিজের সাথে পূর্ণসংখ্যার এক্সওরিং করা 0 দেয় । 0 দিয়ে পূর্ণসংখ্যার জোড় করা (বা এটি একেবারে জোর করা নয়) একই পূর্ণসংখ্যা লাভ করে। এটি ম্যাট্রিক্স ফাঁপা করে দেয়।

কিভাবে এটা কাজ করে

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সেকেন্ডটি দ্বিতীয়-শেষ কলাম বা সারিটিকে দ্বিতীয় চিহ্নিত করে।

— ডেভিডসি

কত সহজ!

— এনজিপিপোরগন

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বিদ্যমান exists আমাদের নিয়ম মেনে চলতে, আপনি এটিকে একটি ফাংশন তৈরি করতে পারেন যা ম্যাট্রিক্স লাগে, যেমন 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অ্যারেতে ফাংশন প্রয়োগ করা সত্যকে 1 এবং ফলসকে 0 তে রূপান্তর করে।

b = Boole[a]

mদ্বারা ম্যাট্রিক্সকে গুণ করুন b। এটি বিতে প্রতিটি ঘরের সাথে সংশ্লিষ্ট ঘরের দ্বারা গুণিত করে।

m b

— DavidC
সূত্র

আপনি ||কয়েকজন বাইট সংরক্ষণ করতে আপনার ওআর হিসাবে ব্যবহার করতে পারেন এবং আপনিও সংরক্ষণ করতে পারেন এমন আরও কয়েকটি বাইট দেখতে পাচ্ছি!

— একটি সিমন্স

একটি সিমন্স, পরামর্শের জন্য ধন্যবাদ।

— ডেভিডসি

# -অনাইটাইজ করুন @ অ্যারেফিল্টার [বিস্তারিত, অ্যারে [সাধারণ @ * তালিকা, মাত্রা @ #], 1] # &

— এনজিপিপোরগান

@ এনজেপিপোরগান, আমি আপনাকে এটি জমা দেওয়ার পরামর্শ দিচ্ছি। (এবং আশা করি এটি কীভাবে কাজ করে তা ব্যাখ্যা করুন!)

— ডেভিডসি

@ ডেভিডসি আমি আমার উত্তর

— এনজিপিপোরগন

6

জিএনইউ শেড, ৩১

4 বাইট সংরক্ষণ করার জন্য @ মান্যাটওয়ার্ককে ধন্যবাদ

সংস্করণ ৪.২.২ বা তার আগে, এই প্রতিশ্রুতি (আলোচনা) এর আগে ।

স্কোর -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/।

— manatwork

1

আপনি কি প্রতিশ্রুতি সম্পর্কিত তথ্য অন্তর্ভুক্ত করতে পারেন যা আপনার উত্তরটি একটি উদ্ধৃতি ব্লকে কাজ করে, সাইটটি আসলেই ধীর এবং সম্পূর্ণ লোড পেতে 1 মিনিট সময় নেয়

— ফেরিবিগ

@ মান্যাটওয়ার্ক ধন্যবাদ - 4 টি বাইট সংরক্ষিত!

— ডিজিটাল ট্রমা

@ ফেরিবিগ এই বিষয় নিয়ে আলোচনা করার জন্য আরও একটি লিঙ্ক যুক্ত করেছেন ।

— ডিজিটাল ট্রমা

5

অক্টাভা, 34 বাইট

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

নোট করুন যে ইনপুটটির জন্য অ্যারে সারিগুলি পৃথক করতে সেমিকোলনগুলির প্রয়োজন:

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

ব্যাখ্যা:

অকটাভ (এবং এমএটিএলবি) অ্যারে সূচকগুলি 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

জেলি , 12 বাইট

ZṖṖ1;¥€
¬ÇÇ×

আমি মনে করি এটি এখনও জেলির চারপাশে আমার মাথা জড়িয়ে রাখে works এটি অনলাইন চেষ্টা করুন!

(-২ বাইটের জন্য @ ডেনিসকে ধন্যবাদ)

ইনপুট অ্যারে 1s এবং 0 সে এর প্রতিটি অ্যারে মাত্রার চেয়ে কম মাত্রার অ্যারে দিয়ে গুণ করে। উদাহরণস্বরূপ, [[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

ES6, 52 48 46 বাইট

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

সম্পাদনা করুন: @ ব্যবহারকারী81655 ধন্যবাদ 4 টি বাইট সংরক্ষণ করা। @ETH প্রোডাকশনগুলির জন্য আরও 2 বাইট সংরক্ষণ করা হয়েছে

— নিল
সূত্র

চতুর! এখানে একটি খুব অনুরূপ পন্থা gযা ছাড়াই কয়েকটি বাইট সংরক্ষণ করে:f=a=>a.map((b,i)=>i&&a[i+1]!=a.x?b.map?f(b):0:b)

— ব্যবহারকারী 81655

সুন্দর কাজ! আমি 48 বাইট গণনা করছি (সম্ভবত আপনি এটি গণনা করতে ভুলে গেছেন f=), তবে আপনি এটি 46 এ নামাতে পারেন:f=a=>a.map((b,i)=>i&&a[i+1]+.5?b.map?f(b):0:b)

— ETH প্রোডাকশনগুলি

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}] } *)

মনে রাখবেন যে সীমানা উপাদানগুলি অনুলিপিযুক্ত যেখানে অপ্রতুল প্রতিবেশী রয়েছে। যখন listদ্বিমাত্রিক হয় তখন এই বৈশিষ্ট্যটি 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

এটি একটি বেনাম ফাংশন যা একটি অ্যারে গ্রহণ করে এবং এটি জায়গায় পরিবর্তিত করে। এটি কল করতে, এটি একটি ভেরিয়েবলের জন্য বরাদ্দ করুন।

পদ্ধতির এখানে বেশ সহজ: জন্য এন দ্বারা মি ইনপুট অ্যারের একটি , আমরা বরাদ্দ একজন _IJ = 0 সকলের জন্য আমি = 2, ..., এন -1 এবং ঞ = 2, ..., মি -1 রেঞ্জ গঠন করে সূচকের। রেঞ্জগুলি খালি থাকতে পারে, যেমন এন বা মি = 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;}

আশা করি প্যারামিটার হিসাবে অ্যারের দৈর্ঘ্য / প্রস্থ নেওয়া ঠিক আছে। আমি মেমসেট / বেজারো দিয়ে একটু ঘুরেছি, তবে কোডের আকারকে মারাত্মকভাবে বাড়িয়েছি 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আমার মেশিনে: পি

— জোশ

আমি বাজি ধরছি এটি এখনও একটি একক সংখ্যা, যা আপনি ব্যবহার করতে পারেন।

— anatolyg

আমি বোঝাতে চেয়েছিলাম যে ঠিক তখনই এটি সিদ্ধান্ত নিতে পারলাম এটি চিড়ির চেয়ে বরং চরিত্রের অ্যারে, কারণ সমস্যাটি কেবল একক সংখ্যা ব্যবহার করে। ঠিক কতটা নিয়ম আমরা বাঁকতে চাই তা নির্ভর করে।

— জোশ

ধন্যবাদ! এখন আমি আলু -->অপারেটরটিও ব্যবহার করতে পারি ;)

— জোশ

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 -

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

{.[1..*-2]»[1..*-2]X=0}2 বাইট সংরক্ষণ করুন

— রায়ফ

@ ইরফ এটি শেষ দুটি ক্ষেত্রে কাজ করতে দেখা যাচ্ছে না

— ব্র্যাড গিলবার্ট বিবিগিল

3

জাভাস্ক্রিপ্ট ES6, 69 66 57 বাইট

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

কিভাবে এটা কাজ করে

এই সমাধানটি ইনপুটটিতে প্রতিটি ওয়াই-ইনডেক্স yএবং এক্স-ইনডেক্সের মাধ্যমে মানচিত্র করে এবং xএই দুটি সূচকের ভিত্তিতে এটিকে ফেলে দেওয়া হবে কিনা তা স্থির করে। আমাদের চারটি কেস রাখতে হবে:

x 0 হয়
y 0 হয়
x অভ্যন্তরীণ অ্যারের দৈর্ঘ্য সমান, বিয়োগ 1
y বাহ্যিক অ্যারের দৈর্ঘ্য সমান, বিয়োগ 1

আমরা একটু গুণ সঙ্গে প্রথম দুই যত্ন নিতে পারেন: x*yআয় 0পারেন iff xবা y0 হয়, এবং একটি ধনাত্মক পূর্ণসংখ্যা অন্যথায়। এখন তৃতীয়টির জন্য: আমরা যাচাই করতে পারতাম X.length>x+1, তবে এতে অনেকগুলি বাইট লাগে। এটি করার আরেকটি উপায় হ'ল সামনের আইটেমটি মিথ্যা কিনা তা পরীক্ষা করা, যথা undefined, অস্তিত্বহীন আইটেমটি অ্যাক্সেস করার চেষ্টা করার সময় আপনি যা পান। যাইহোক, পরবর্তী আইটেমটি 0এটির সাথেও মিলছে , তাই এটি না ঘটে তা নিশ্চিত করার জন্য আমরা 0.5 যোগ করি:

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

রেটিনা ,31 24 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}}

সম্পাদনা একটি ভুল করা হয়েছে, আমি ভেবেছিলাম যে একটি [x, y] দশম সারি এবং yth কোল। স্পষ্টতই এটি একটি [x] [y] হওয়া উচিত!

সম্পাদনা করুন আমি কোডটি পরীক্ষা করতে ভুলে গিয়েছি এবং লুপের ভিতরে প্রতিবার কলামটি শূন্যে সেট করতে হবে, +12 বাইট। : /

— HyperNeutrino
সূত্র

3

Haskell,, 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
     )

— ZETA
সূত্র

আপনি চালু করতে সক্ষম হওয়া উচিত ++[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=দুই বাইট জন্য।

— নিমি

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}

ব্যাখ্যা

একটি আর্গ সঙ্গে বন্ধ

g={a->

প্রথম এবং শেষ উপাদানগুলি এড়িয়ে চলা অভ্যন্তরীণ অ্যারের উপরে আইট্রেট করুন

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;
        }
    }
}

— ZETA
সূত্র

— ইনপুটটিতে

1

পিএইচপি, 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);'

ধ্রুব আকারের সারি (ম্যানটওয়ার্ক থেকে থেক্স) ধরে ধরে একটি বাইট সংরক্ষণ করা হয়েছে
একটি বেনিটকে একটি অনামী ফাংশন তৈরি করে সংরক্ষণ করেছেন
পরবর্তী অ্যারে আইটেমটির সত্যতা ব্যবহার করে 7 বাইট সংরক্ষণ করা হয়েছে count, কলগুলি প্রতিরোধ করা , যা কোডগল্ফের পক্ষে অনেক দীর্ঘ নাম

— aross
সূত্র

ম্যাট্রিক্স প্রক্রিয়া করার সময়, সমস্ত উপ-অ্যারে একই দৈর্ঘ্য হওয়া উচিত। সুতরাং অভ্যন্তরীণ 1 টি অক্ষর forছাড়াই সবসময় পুনরাবৃত্তি করা নিরাপদ count($z[0])-1।

— manatwork

1

এপিএল, 17 বাইট 15 বাইট

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

কিভাবে এটা কাজ করে

⍳⍴⍵ একটি 2D অ্যারে তৈরি করে যেখানে সমস্ত ঘর আর্গুমেন্টের সমস্ত ঘরগুলির স্থানাঙ্ক ধারণ করে।
1∊¨এই ধরণের প্রতিটি ঘরে 1 রয়েছে এবং সন্ধান করে যদি 1 থাকে তবে অন্যথায় 0 প্রদান করে। এটি একটি ম্যাট্রিক্স তৈরি করে যেখানে প্রথম সারি এবং প্রথম কলামটি 1s এবং বাকী সমস্ত 0 হয়।
(⌽∨⊖) লজিকাল "বা" ম্যাট্রিক্সের দুটি সংস্করণের সাথে একত্রিত হয়, একটি প্রথমদিকে বিপরীত হয় এবং একটি শেষ অক্ষের সাথে বিপরীত হয়।
⍵× হ'ল মানক গুণ।

— lstefano
সূত্র

আপনি (⊣∨⊖∘⌽) এর সাথে (⊖∨⌽) প্রতিস্থাপন করতে পারেন, দুটি বাইট কম

— মরিস জুকা

উজ্জ্বল! আমাকে যে করতে দিন!

— lstefano

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

স্মাইলব্যাসিক, 69 51 বাইট

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

একটি অ্যারেতে 2D অঞ্চল পূরণ করার জন্য সাধারণত একটি লুপে ফিল প্রয়োজন। তবে গ্রাফিক্স পৃষ্ঠায় 2D ডেটা নিয়ে কাজ করা অনেক সহজ, তাই প্রথমে অ্যারেটি এখানে অনুলিপি করা হয়।

ওহ আমি ভেবেছিলাম আমি গ্রাফিক্স কমান্ডগুলি ব্যবহার করে খুব চালাক হয়েছি ... তবে এটি পূরণের জন্য অনেক সময় পূরণ করা আসলে সংক্ষিপ্ত।

যাইহোক, ফাংশন ইনপুটগুলি অ্যারে এবং প্রস্থ / উচ্চতা (এটি স্মাইলবাসিকের মধ্যে স্ট্যান্ডার্ড কারণ কোনও অ্যারের মাত্রা চেক করার কোনও উপায় নেই))

— 12Me21
সূত্র

0

এপিএল (ডায়ালগ ক্লাসিক) , 12 বাইট

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

এটি অনলাইন চেষ্টা করুন!

⍉⌽⍵ সাধারণত ঘূর্ণন হয় (অনুভূমিকভাবে বিপরীত এবং স্থানান্তর)

এখানে আমরা এটি একত্রিত করি 0⍪1↓⍵যা দিয়ে প্রথম সারিটি শূন্যগুলির সাথে প্রতিস্থাপন করে (এক সারি ফেলে, তারপরে 0 টি সংযুক্ত করে) একটি একক ট্রেনে:⍉0⍪1↓⌽

⍣4 4 বার পুনরাবৃত্তি

⊢- মূল ম্যাট্রিক্স থেকে বিয়োগ করে

— ngn
সূত্র

একটি অ্যারে ফাঁকা

কাজটি

বিধি এবং স্কোরিং

পরীক্ষার মামলা

লিডারবোর্ড

এমএটিএল , 9 বাইট

জাভা 7, পুরো নামযুক্ত ফাংশন হিসাবে: 85 85

জেলি, 18 17 15 9 বাইট

পটভূমি

কিভাবে এটা কাজ করে

গণিত, 27 বাইট

আর , 33 48 বাইট

ম্যাথমেটিকা 81 76 বাইট

কিভাবে এটা কাজ করে

জিএনইউ শেড, ৩১

ব্যাখ্যা

অক্টাভা, 34 বাইট

ব্যাখ্যা:

জেলি , 12 বাইট

সম্পূর্ণ ব্যাখ্যা

ES6, 52 48 46 বাইট

জাভাস্ক্রিপ্ট, 62 59 56 বাইট

গণিত, 55 বাইট

পাইথন, 50 বাইট

জুলিয়া, 50 35 বাইট

সি, 62 বাইট

পার্ল 6 , 28 বাইট

ব্যবহার

জাভাস্ক্রিপ্ট ES6, 69 66 57 বাইট

কিভাবে এটা কাজ করে

রেটিনা ,31 24 22

জাভা 8, ল্যাম্বদা ফাংশন হিসাবে: 82 83 95 চর / বাইট

Haskell,, 59 58 বাইট

সম্প্রসারিত

পাইথ, 18 বাইট

গ্রোভি, 70 বাইট

ব্যাখ্যা

টেস্ট

আর, 71 64 57 বাইট

সি ++, 80 79 বাইট

প্রসারিত সংস্করণ

পিএইচপি, 82 81 80 71 বাইট

এপিএল, 17 বাইট 15 বাইট

কিভাবে এটা কাজ করে

পার্ল, 34 + 2 = 36 বাইট

লুয়া, 69 বাইট

স্মাইলব্যাসিক, 69 51 বাইট

এপিএল (ডায়ালগ ক্লাসিক) , 12 বাইট