চৌম্বকীয় ভাস্কর্য

Question

এটি গ্রাফ তৈরির ক্ষেত্রে আমার আগের চ্যালেঞ্জের একটি শিথিল ধারাবাহিকতা ।

পটভূমি

একজন উদ্ভট শিল্পী তাঁর ভাস্কর্যগুলির কাঠামোগত অখণ্ডতা অনুমান করতে আপনাকে নিয়োগ করেছেন। তিনি একগুচ্ছ কিউব আকৃতির চুম্বক নিয়ে এবং সেগুলি একে একে একটি বিশাল স্তূপে ফেলে তার শিল্পকর্ম তৈরি করেন। তার পদ্ধতির আরও বিশ্লেষণ করতে আমরা নিম্নলিখিত দ্বি-মাত্রিক মডেলটি ব্যবহার করি। আমরা একটি খালি মেঝে দিয়ে শুরু করি, এবং #কোনও পূর্ণসংখ্যার স্থানাঙ্কে একটি চুম্বক ফেলে রাখি , বলুন 0:

       |
       v
       #
===============
       0

যদি অন্য চৌম্বকটি এটিকে বাদ দেওয়া হয় 0তবে এটি পূর্বের একের উপরে উঠে যায়:

       |
       v
       #
       #
===============
       0

এখন, আসুন এখানে আরও একটি চুম্বক 0এবং তারপরে একটি 1:

        |
       #v
       ##
       #
===============
       0

উপরের মতো দেখা গেছে, একটি পতনশীল চৌম্বকটি দ্বিতীয় চৌম্বকটি যেভাবে চলে যায় তার সাথে আটকে থাকে (প্রথমটি কেবল এটি ধীর করে দেয়)। দ্বিতীয় চৌম্বকটি সরাসরি প্রথমটির নীচে হওয়া উচিত নয় এবং উভয় পক্ষের চৌম্বকটি এখনও একটি চৌম্বক হিসাবে গণনা করে:

      #   #
      ##|##
      # v #
      ### #
      #   #
===============
       0

শিল্পীরা চান আপনি চূড়ান্ত ভাস্কর্যটিতে সর্বাধিক উল্লম্ব ফাঁকটি গণনা করতে পারবেন, অর্থাত, একই কলামে দুটি চৌম্বক, বা একটি চৌম্বক এবং এর নীচে ভূমির মধ্যে খালি জায়গার সর্বাধিক সংখ্যা। উপরের ছবিতে এই সংখ্যাটি 3 (কলামে 2) হবে।

ইনপুট

পূর্ণসংখ্যাগুলির একটি তালিকা, যেখানে স্থানাঙ্কগুলি উপস্থাপন করে যেখানে শিল্পী তার চৌম্বকগুলি ফেলে দেয়, বাম থেকে ডানে পড়েন। আপনি ধরে নিতে পারেন যে স্থানাঙ্কগুলি সন্তুষ্ট হয় -1024 <= i < 1024এবং তালিকার দৈর্ঘ্য সর্বাধিক হয় 1024, যদি এটি সহায়তা করে।

আউটপুট

চূড়ান্ত ভাস্কর্যটিতে সর্বাধিক উল্লম্ব ফাঁক। খালি ভাস্কর্যটির ফাঁক রয়েছে -1, এবং এই কেসটি অন্তর্ভুক্ত করতে হবে, যেহেতু আমাদের ভাস্করটি একজন দাদী।

অতিরিক্ত বিধি

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

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

[] -> -1
[0,2,1] -> 0
[0,0,0,0,0,1,-1] -> 3
[0,0,0,0,0,1,1,1,2] -> 4
[1,1,2,2,2,2,2,2,1] -> 2
[1,1,2,2,2,2,2,2,1,0,1,0] -> 2
[1,2,1,2,1,2,1,2,2,2,2,1,0] -> 3
[-1,-1,-1,1,1,1,0] -> 1
[-1,-1,-1,-1,2,2,1,1,2,2,2,1,0] -> 2
[-2,-2,-2,-1,-1,-1,0,0,0,1,1,1,2,2,2,3,3,4,4,5,5,5,6] -> 6

Answer 1

ডায়ালগ এপিএল, 73 70 টি অক্ষর

{y←⍬⋄⌈/¯1,,¯1-2-/0,x⊢⌸{y,←⌈/(1+y/⍨0=⍵),Y⊃⍨2⊃⍒Y←1 1,∪y/⍨1=⍵}¨|x-¯1↓¨,\x←⍵}

{y←⍬⋄¯1⌈⌈/,¯1-2-/¯1,⍵⊢⌸{y,←⌈/(1+y/⍨0=⍵),⊃1↓{⍵[⍒⍵]}∪y/⍨1=⍵}¨|⍵-¯1↓¨,\⍵}

First statement:
       y←⍬  initialize semi-global variable y with an empty vector
Second statement, from right to left:
         ⍵  the vector of x coordinates
       ,\⍵  concat-scan: all prefixes of ⍵ of length 1, 2, ..., ≢⍵
   ¯1↓¨,\⍵  drop the last element of each prefix, lengths are 0, 1, ..., (≢⍵)-1
|⍵-¯1↓¨,\⍵  for each x: magnitudes of differences between x and its predecessors
 {...}¨...  execute the code in parens for each item of the argument
         ⍵  is now a single vector of differences from those described above
       1=⍵  boolean mask, where are our neighbouring xs?
    y/⍨1=⍵  select the ys corresponding to our neighbouring xs
   ∪y/⍨1=⍵  unique ys
   {⍵[⍒⍵]}  sort descending
       ⊃1↓  first of one-drop, i.e. get the second element if it exists, otherwise 0
       0=⍵  which previous xs are the same as our x?
  1+y/⍨0=⍵  select the corresponding ys and add 1 to them
        ⌈/  maximum of all the ys described so far
       y,←  append to the semi-global y
            the result from {} will be identical to y
  ⍵⊢⌸{...}  a matrix of ys, grouped in rows by x (which is now in ⍵) and zero-padded
       ¯1,  prepend ¯1 to the left of each row
       2-/  differences between consecutive horizontal elements, result is a matrix
       ¯1-  negative one minus each element of the matrix
         ,  ravel the matrix (linearize it to a vector)
        ⌈/  maximum; if the vector is empty, return ¯1.8e308, a very small number
     ¯1⌈⌈/  greater of ¯1 and the ⌈/  to avoid the very small number

Comments

দ্রষ্টব্য: এটি ইউটিএফ -8 ধরে ধরে 122 বাইট দীর্ঘ (চ্যালেঞ্জটি বাইটে রয়েছে)।

— এমটিএনভিউমার্ক

দেখুন codegolf.stackexchange.com/questions/42536/...

— ngn

আমি বেশ সহানুভূতিশীল: আমার গল্ফ হাস্কেলের নন-এসসিআইআই অক্ষর ব্যবহার করার জন্য আমাকে প্রায়শই ডিন করা হত। তখন থেকে আমি বেশ মনযোগী হয়েছি যদি প্রশ্নটি অক্ষর বা বাইট দ্বারা গণনা নির্দিষ্ট করে।

— এমটিএনভিউমার্ক 17

@ এমটিএনভিউমার্ক স্কোর মানে বাইট দ্বারা স্কোর করা মানে ইউটিএফ -8 বাইট দ্বারা স্কোর করা নয়। এপিএলের পক্ষে এটি করা এএসসিআইআইকে একটি গুরুত্বপূর্ণ মান হিসাবে স্বীকৃতি না দেওয়ার জন্য এটি বয়স্ক হওয়ার জন্য শাস্তি দিচ্ছে। এপিএলের চরিত্র সেটটি একটি একক বাইট কোডপেজের মধ্যে সহজেই ফিট করে এবং কোডকটি বিদ্যমান । সুতরাং কোডেককে প্রতিটি অক্ষরকে এনকোডিং হিসাবে ব্যবহার করা একটি বাইট। অন্যদিকে, আপনি যদি হাস্কেল-তে নন-এএসসিআইআই অক্ষর ব্যবহার করেন তবে আপনাকে এমন একটি এনকোডিং ব্যবহার করতে হবে যার মধ্যে ASCII এবং নন-ASCII উভয় অক্ষর রয়েছে - এবং এটি সাধারণত ইউটিএফ -8 থাকে।

— মার্টিন এন্ডার

@ জিএনএন - এখন বেশিরভাগ মেটা পোস্ট পড়ে দেখে মনে হচ্ছে হায় হায় আফসোস এখনও কাদামাটি হয়ে আছে। যাইহোক, সম্ভবত সেরা হবে, যখন চ্যালেঞ্জটি বাইটে স্কোর করা হয়, বাইটে এপিএল স্কোর করা, তবে কোথাও ব্যবহৃত এনকোডিংয়ের উল্লেখ করুন।

— এমটিএনভিউমার্ক

Answer 2

হাস্কেল - 217 185 182 বাইট

import Data.List
r g n m|m==n=max(head(g m)+1)((reverse.(0:).nub.sort$g(m-1)++g(m+1))!!1):g m|1<3=g m
j x=(-1)-minimum(0:(map(foldl r(\_->[0])x)[-1024..1024]>>=(tail>>=zipWith(-))))

ব্যবহার:

j [1,2,1,2,1,2,1,2,2,2,2,1,0]

এই ফাংশনটি অন্য একটি ফাংশন তৈরি করে যা প্রদত্ত এক্স-পজিশনের জন্য চৌম্বক ওয়াই-পজিশনের একটি তালিকা প্রদান করে। এটির সাহায্যে এটি সমস্ত এক্স-পজিশনের জন্য ফাঁকগুলি গণনা করে -1024 .. 1024 এবং সর্বাধিক লাগে (সম্পাদনা করুন: এখন আমি সর্বনিম্ন নিচ্ছি, কারণ ফাঁকগুলি নেতিবাচক: ব্যবধানটি বৃহত্তরটি কম)।

Comments

চালাক পদ্ধতির! আশা করি আপনি কিছু মনে করবেন না যে আমি এটি কিছুটা কমিয়ে দিয়েছি।

— এমটিএনভিউমার্ক

@ এমটিএনভিউমার্ক: মোটেও নয়। আমি সেভ করতে 3 আরও বাইট পেয়েছি: না , নেতিবাচক সংখ্যার যান এবং নিতে । flip-minimum

— নিমি

আমার রেপোতে , আপনি এই কোডটি পেতে পারেন, 42997-চৌম্বকীয়.হস যা পরীক্ষার ক্ষেত্রেও পরীক্ষার জোয়ার এবং ভিজ্যুয়ালাইজারটি ভাস্কর্যগুলি প্রদর্শন করে includes

— এমটিএনভিউমার্ক

Answer 3

জাভাস্ক্রিপ্ট, 201 193

F=P=>{m=[];for(p of P){s=2;c=m[p]=m[p]||[];for(i=1e4;~i&&s;i--){if((m[p-1]||[])[i]||(m[p+1]||[])[i])s--;if(c[i-1]) s=0}c[++i]=1}g=-1;m.map(c=>{ d=0;for(i in c){g=i-d>g?i-d:g;d=++i} });return g}

এফ ([1,1,2,2,2,2,2,2,1]) === 2

বা পাঠযোগ্য সংস্করণ

F=P=>{
  m=[];  // magnet positions
  for(p of P){ // every dropped magnet
    s=2; // initial speed
    c=m[p]=m[p]||[]; // column where magnet is dropping
    for(i=1e4;~i&&s;i--){ // continue until at floor or zero speed
      if((m[p-1]||[])[i]||(m[p+1]||[])[i])s--;  // magnet on either side, decrease speed
      if(c[i-1]) s=0; // magnet is directly below
    }
    c[++i]=1;
  }
  g=-1; // maximum gap
  m.map(c=>{ 
          d=0;for(i in c){g=i-d>g?i-d:g;d=++i;} 
       });
  return g;
};

Answer 4

পাইথন 2.7, 327

from itertools import * 
s=input()
if s:m=min(s);l=[[] for _ in range(max(s)-m+3)]
for t in s:
    i=t-m+1;r=l[i];c=[x or y for x,y in izip_longest(l[i-1],l[i+1])][::-1][1:];j=len(c)-c.index(1)-1-len(r) if any(c) else 0;l[i]=r+[0]*j+[1]
print -1 if not s else max([len(list(q)) if b==0 else 0 for k in l for b,q in groupby(k)])

সাদা স্পেস গল্ফ করার আগে এটি দেখতে এমন দেখাচ্ছে:

from itertools import * 
s=input()
if s:
    m=min(s)
    l=[[] for _ in range(max(s)-m+3)]
for t in s:
    i=t-m+1;r=l[i]
    c=[x or y for x,y in izip_longest(l[i-1],l[i+1])][::-1][1:]
    j=len(c)-c.index(1)-1-len(r) if any(c) else 0
    l[i]=r+[0]*j+[1]
print -1 if not s else max([len(list(q)) if b==0 else 0 for k in l for b,q in groupby(k)])

বেশিরভাগ আমার নিজের সুবিধার জন্য আরও জটিল রেখার ব্যাখ্যা এখানে।

l=[[] for _ in range(max(s)-m+3)] 

এটি দৈর্ঘ্য সর্বাধিক (ড্রপস) -মিনি (ড্রপস) +1 এবং উভয় পাশের একটি স্থানধারকের খালি তালিকার একটি অ্যারে তৈরি করে। আমি সর্বদা খালি তালিকার একটি অ্যারে তৈরি করতে [[]] * কে লিখতে চাই, তবে এটি কেকে একই খালি তালিকার দিকে নির্দেশ করে।

c=[x or y for x,y in izip_longest(l[i-1],l[i+1])][::-1][1:] 

ইটারটুলগুলি থেকে izip_longest ফাংশনটি জিপের মতো, তবে তালিকাগুলি একসাথে জিপ করার জন্য কোনওটির সাথে সংক্ষিপ্ত তালিকায় প্রবেশ করে। বিভাজক [:: - 1] "এবং" তুলনা থেকে 0 এবং 1 এর তালিকাটিকে বিপরীত করে। পরের লাইনে সূচক পদ্ধতিটি ব্যবহার করার জন্য তালিকাটি বিপরীত হয়, যা কোনও উপাদানের প্রথম উদাহরণটি খুঁজে পায়। যেহেতু কোনও মৌলিক কলামের শেষ উপাদানটি 1 হতে হবে তাই বিপরীত তালিকার এটি প্রথম উপাদান এবং এটি [1:] স্লাইসের মাধ্যমে উপেক্ষা করা হবে।

j=len(c)-c.index(1)-1-len(r) if any(c) else 0 
l[i]=r+[0]*j+[1]

প্রথমে কলাম i এর দৈর্ঘ্য এবং সংলগ্ন কলামগুলিতে দ্বিতীয় 1 এর অবস্থানের মধ্যে পার্থক্য গণনা করুন। পার্থক্যটি যদি ইতিবাচক হয় তবে 1 যোগ করার আগে কলাম আইতে অনেকগুলি শূন্য যুক্ত করুন Any যেকোন ধনাত্মক সংখ্যা বার [0] খালি তালিকা।

max([len(list(q)) if b==0 else 0 for k in l for b,q in groupby(k)])

ইটারটুলগুলি থেকে ফাংশন গ্রুপবিলে ক্রমাগত উপাদানগুলির উপসর্গগুলিতে একটি তালিকা বিভক্ত হয়। এই লাইনটি সমস্ত কলামে শূন্যের সমস্ত উপসর্গের সর্বাধিক দৈর্ঘ্যের সন্ধান করে। প্রতিটি উপসর্গের কিউটিকে তালিকায় কাস্ট করা প্রয়োজনীয়, কারণ গ্রুপবাই জেনারেটর ফিরিয়ে দেয় (সমস্ত ইটারটোল ফাংশনগুলির মতো) যা স্বাভাবিকভাবে লেন পদ্ধতি সমর্থন করে না।

Answer 5

জাভা - 281 বাইট

অনেকটাই অকপট.

প্রথমে এটি একটি অ্যারেতে ভাস্কর্যটি তৈরি করে

তারপরে এটি সর্বাধিক ব্যবধানটি সন্ধান করে।

int a(int[]b){
        int[][]d=new int[9999][9999];
        int g,r,t,y=-1;
        for(int c:b){
            c+=5000;
            g=0;
            for(r=9998;r>=0;r--){
                if(r==0||d[c][r-1]==1){d[c][r]=1;break;}
                if((d[c-1][r]==1||d[c+1][r]==1)&&++g==2){d[c][r]=1;break;}
            }
        }
        for(int[] k:d){
            t=0;
            for(int i:k){
                if(i==0)t++;
                else{if(t>y)y=t;t=0;}
            }
        }
        return y;
    }

ছোট -

int a(int[]b){int[][]d=new int[9999][9999];int g,r,t,y=-1;for(int c:b){c+=5000;g=0;for(r=9998;r>=0;r--){if(r==0||d[c][r-1]==1){d[c][r]=1;break;}if((d[c-1][r]==1||d[c+1][r]==1)&&++g==2){d[c][r]=1;break;}}}for(int[] k:d){t=0;for(int i:k){if(i==0)t++;else{if(t>y)y=t;t=0;}}}return y;}

Comments

আপনিই প্রথম প্রতিস্থাপন দ্বারা একটি বাইট সংরক্ষণ করতে পারবেন ||সঙ্গে |। এছাড়াও, yএটি মুদ্রণের পরিবর্তে ফিরে আসা 9 বাইট সাশ্রয় করে।

— Ypnypn

@Ypnypn, ধন্যবাদ! বিটিডাব্লু, আপনার প্রথম বিবৃতিতে একটি অ্যারেআইন্ডেক্সআউটআউটবাউন্ড ব্যতিক্রম (-1) ছুঁড়েছে বলে মনে হচ্ছে। (বিটওয়াইজ অপারেটরগুলির সাথে আমার খুব বেশি অভিজ্ঞতা নেই)

— স্ট্রেচ ম্যানিয়াক

এটা তোলে 1.5 বছর সম্পর্কে হয়েছে, কিন্তু আপনি গলফ তা আরো কিছু: ( 272 বাইট ): int a(int[]b){int z=9999,d[][]=new int[z][z],g,r,t,y=-1;for(int c:b){c+=z/2;g=0;for(r=z;--r>-2;){if(r==0||d[c][r-1]==1){d[c][r]=1;break;}if((d[c-1][r]==1|d[c+1][r]==1)&&++g==2){d[c][r]=1;break;}}}for(int[]k:d){t=0;for(int i:k){if(i==0)t++;else{if(t>y)y=t;t=0;}}}return y;}। পরিবর্তনের সংক্ষিপ্তসার: z=9999যুক্ত এবং ব্যবহার করা হয়েছে; intএবং int[][]ক্ষেত্রের সূচনা একটিতে একীভূত করা হয়েছে; দ্বিতীয় ||দ্বারা প্রতিস্থাপিত হয় |; for(r=9998;r>=0;r--)পরিবর্তিত হয়েছেfor(r=z;--r>-2;)

— কেভিন Cruijssen