भविष्यवाणी करें कि आदमी कहां जाएगा

Question

एक आदमी (0, 0)ऊंचाई hऔर चौड़ाई वाले शहर के उत्तर-पश्चिम कोने में रहता है w। रोज वह अपने घर से सीमा की ओर (?, w)या फिर टहलता है (h, ?)। निम्नलिखित उदाहरण में, आदमी (3, 3)आज जाता है।

(0, 0) +--+  +  +  . (0, 4)
          |         
       +  +--+--+  .
                |   
       +  +  +  +  .
                |   
(3, 0) .  .  .  .  . (3, 4)

आदमी प्रत्येक बिंदु पर एक सा रिकॉर्ड करता है ( +ऊपर उदाहरण में)। हर बार जब वह किसी बिंदु पर पहुंचता है, तो वह पूर्व की ओर जाता है यदि बिट 1और दक्षिण अन्यथा। उसके जाने के बाद बिट को फ़्लिप किया जाता है। उदाहरण के लिए:

Day 1: 1--0  1  1    Day 2: 0  1  1  1    Day 3: 1--1--1--1--  Day 4: 0  0  0  0  
          |                 |                                         |           
       0  1--0  0           0  0  1  0           1  0  1  0           1--0  1  0  
             |              |                                            |        
       1  0  1--0           1--0  0  1           0  1  0  1           0  1--0  1  
                |              |                                            |     
Destination: (3, 3)  Destination: (3, 1)  Destination: (0, 4)  Destination: (3, 2)

शहर के आकार और आदमी के रिकॉर्ड को देखते हुए, nदिनों के बाद आदमी की मंजिल की गणना करें ।

इनपुट:

पहली पंक्ति में तीन पूर्णांक हैं h, wऔर n।

निम्नलिखित hपंक्तियों में wपूर्णांक हैं, जो आदमी के रिकॉर्ड को दर्शाते हैं।

h <= 1000, w <= 1000, n <= 1000000000

आउटपुट:

दो पूर्णांक, nदिनों के बाद आदमी के गंतव्य को दर्शाते हुए ।

नमूना इनपुट:

3 4 3
1 0 1 1
0 1 0 0
1 0 1 0

नमूना आउटपुट:

0 4

नमूना कोड:

#include <iostream>
using namespace std;
bool d[1000][1000];
int main(){
    int h, w, n;
    cin >> h >> w >> n;
    for(int i = 0; i < h; i++)
        for(int j = 0; j < w; j++)
            cin >> d[i][j];
    int i, j;
    while(n--)
        for(i = 0, j = 0; i < h && j < w;){
            bool &b = d[i][j];
            d[i][j] ? j++ : i++;
            b = !b;
        }
    cout << i << " " << j << endl;
}

स्कोरिंग:

• UTF-8 में सबसे कम बाइट गिनती जीतती है।
• यदि आपके कोड का रनिंग टाइम स्वतंत्र है n, तो अपना स्कोर 50% कम करें।
  • बस सभी 1000000000 दिनों के परिणामों की गणना न करें या इस बोनस को प्राप्त करने के लिए कुछ भी इसी तरह मूर्खतापूर्ण करें। एक कुशल एल्गोरिथ्म का पता लगाएं!

Comments

2 चीजें जो मुझे समझ में नहीं आईं। आउटपुट, कभी-कभी आप 0 इंडेक्स का उपयोग दूसरी बार करते हैं जो आप नहीं करते हैं। वह कैसे काम करता है? क्या यह सीमा + 1 जैसा होना चाहिए? दूसरी चीज स्कोरिंग के साथ दूसरी लाइन है। आपका क्या मतलब है?

— त्यूं प्रैंक

दिन 4 आउटपुट 3,2 सही होना चाहिए?

— तेउन प्रैंक

यदि, कोई बात नहीं nहै, तो मेरा कोड सभी 1000000000 दिनों के परिणामों की गणना करता है, फिर परिणाम का उत्पादन करता है n, क्या मुझे अभी भी -50% बोनस मिलता है?

— user12205

@ अब आप इसे इस तरह डालते हैं, यह समझ में नहीं आता है? इसके लिए धन्यवाद: पी

— तेउन प्रोंक

@TeunPronk हां। यह मेरी गलती है।

— जॉनचेन 902

Answer 1

गोल्फस्क्रिप्ट, 52.5 (50% बोनस के साथ 105 अक्षर)

~](;(\((2$(1,*+\@/{]zip 0\{~@@+.2$!+2/\@+.2/\@[\1&]}%zip~@;}%\;[{.0=0=\1${{1>}%}{1>}if.{~}%}do;].1-,n@0-,

संस्करण बहुत कुशल है और बड़े मूल्यों के लिए भी ऑनलाइन परीक्षण किया जा सकता है ।

यह user2357112 के समाधान के समान दृष्टिकोण का उपयोग करता है ।

Comments

कृपया स्पष्टीकरण न मांगें ;-) मैं इसे तोड़ने और बग़ैर डिबग किए बिना इसे बदल भी नहीं सकता।

— हावर्ड

Answer 2

पायथन 2, 192 बाइट्स * 0.5 बोनस = 96

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

जॉन्चेन 902 के समाधान से प्रेरित पुश-आधारित दृष्टिकोण के कारण पर्याप्त सुधार :

r=lambda:map(int,raw_input().split())
h,w,n=r()
v=[n]+w*[0]
x=y=0
for i in range(h):
 for j,b in enumerate(r()):
    if i-x==j-y==0:d=v[j]&1^b;x+=d;y+=1^d
    f=v[j]+b>>1;v[j]-=f;v[j+1]+=f
print x,y

पिछला, पुल-आधारित कार्यान्वयन:

r=lambda i:map(int,raw_input().split())
h,w,n=r(0)
x=range(h)
g=map(r,x)
v=[w*[0]for i in x]
v[0][0]=n-1
for i in x:
 for j in range(w):v[i][j]+=(i and(v[i-1][j]+(1^g[i-1][j]))/2)+(j and(v[i][j-1]+g[i][j-1])/2)
i=j=0
while i<h and j<w:f=g[i][j]^v[i][j]&1;j+=f;i+=1^f
print i,j

मूल, असम्बद्ध संस्करण:

h, w, n = map(int, raw_input().split())
grid = [map(int, raw_input().split()) for i in xrange(h)]

# Determine the number of times each cell was visited in the first n-1 trips
visits = [[0]*w for i in xrange(h)]
visits[0][0] = n-1
for i in xrange(h):
    for j in xrange(w):
        if i:
            # Count visits from above cell
            visits[i][j] += (visits[i-1][j] + (not grid[i-1][j])) // 2
        if j:
            # Count visits from left cell
            visits[i][j] += (visits[i][j-1] + grid[i][j-1]) // 2

# Flip the bits corresponding to each cell visited an odd number of times
for i in xrange(h):
    for j in xrange(w):
        grid[i][j] ^= visits[i][j] & 1

# Figure out where the final trip ends
i = j = 0
while i < h and j < w:
    if grid[i][j]:
        j += 1
    else:
        i += 1

print i, j

Comments

आप छोटा कर सकते हैं not करने के लिए 1^और लंबे समय से अगर हालत लिखा जा सकता है f=g[i][j]^v[i][j]&1 j+=f i+=1^f।

— हावर्ड

@ हॉवर्ड: धन्यवाद। संपादन लागू।

— user2357112

आप की अनुमति देते हैं rएक पैरामीटर (लेने के लिए r = lambda x: ...), तो आप छोटा कर सकते हैं g=[r()for i in x]करने के लिए g=map(r,x)।

— रॉबर्टो बोनावलेट

@ रॉबर्टो बोनलवलेट: यूप। सलाह लागू की।

— user2357112

Answer 3

रूबी, 159 143

n,*l=$<.read.split$/
i=->a{a.split.map &:to_i}
x=y=l.map!{|k|i[k]}
(n=i[n])[-1].times{x=y=0
(x+=f=l[x][y]^=1;y+=f^1)while x<n[0]&&y<n[1]}
p x,y

पहली लाइन *ऑपरेटर का उपयोग एक चर में इनपुट की पहली पंक्ति को खींचने के लिए करती है, और बाकी इनपुट को दूसरे में। फिर एक iफ़ंक्शन को रूपांतरित करने के लिए परिभाषित किया "1 2 3 4"जाता है [1, 2, 3, 4], जिसे दोनों पर लागू किया जाता है lऔर n। ( xऔर yबाद के लिए सहेजे गए हैं।)

n[-1]का अंतिम तत्व है n, इसलिए निम्न ब्लॉक (सिमुलेशन) को कई बार निष्पादित किया जाता है। पहले, xऔर yशून्य पर आरंभीकृत किया जाता है (वे ब्लॉक के बाहर घोषित किए जाते हैं ताकि उनका दायरा काफी बड़ा हो), और फिर सिमुलेशन लाइन निष्पादित की जाती है, जो कि बहुत ही आत्म-व्याख्यात्मक है, लेकिन यहां कुछ भी कमेंटरी है:

l[x][y]<1?            is it zero (less than one)?
x+=l[x][y]=1          if it's zero, set it to one, and (conveniently) we can add that to x
:y+=(l[x][y]=0)+1     otherwise, set it to zero, add one, and add that to y
 while x<n[0]&&y<n[1] keep doing this while we're still inside the array

संपादित करें: हावर्ड द्वारा प्रदान की गई नई सिमुलेशन लाइन, धन्यवाद! मुझे पूरा यकीन है कि मैं समझता हूं कि यह कैसे काम करता है लेकिन मेरे पास स्पष्टीकरण जोड़ने का समय नहीं है, इसलिए बाद में एक जोड़ा जाएगा।

अंत में, p x,yसंख्याओं को आउटपुट करता है, और हम कर रहे हैं!

Comments

कुछ बुनियादी जीत: नईलाइन को बदल दें $/और जबकि लूप को कम किया जा सकता है (x+=f=l[x][y]^=1;y+=f^1)while x<n[0]&&y<n[1]}।

— हॉवर्ड

Answer 4

डेल्फी एक्सई 3 (437 बाइट्स ) 897 874 बिना बोनस की गिनती के)

जब मैंने सोचा कि बोनस के साथ इसे कैसे हल किया जाए, तो मैंने निम्नलिखित के बारे में सोचा।
यदि आप 4 दिन चलते हैं तो सेल 0,0 4 बार बदल जाती है। इसके दाईं ओर की सेल को उसके नीचे की सेल से दो बार बदला जाता है।
यदि दिनों की असमान संख्या है और सेल में संख्या 1 से शुरू होती है, तो दाईं ओर सेल सेल के नीचे एक से अधिक हो जाती है, और यदि सेल 0 है, तो दूसरे तरीके से।

प्रत्येक सेल के लिए ऐसा करने से आप देख सकते हैं कि क्या अंतिम मूल्य को बदलना चाहिए: सेल को एक्स बार बदल दिया गया था। यदि X mod 2> 0 है तो सेल को बदलें।

निम्नलिखित कोड में परिणाम:
{JohnChen902 पर फुसफुसाते हुए} क्या अब मुझे आपका उत्थान मिलेगा? : पी

uses SysUtils,Classes,idglobal;var a:TArray<TArray<byte>>;b:TArray<TArray<int64>>;h,w,x,y,t:int16;n:int64;s:string;r:TStringList;tra:byte;begin r:=TStringList.Create;readln(h,w,n);h:=h-1;w:=w-1;for y:=0to h do begin readln(s);r.Add(StringReplace(s,' ','',[rfReplaceAll]));end;SetLength(a,h);SetLength(b,h);for y:=0to h do begin SetLength(a[y],w);SetLength(b[y],w);for x:=1to Length(r[y])do a[y][x-1]:=Ord(r[y][x])-48;end;b[0][0]:=n-1;for Y:=0to h do for X:=0to w do begin t:=b[y][x];if x<w then b[y][x+1]:=b[y][x+1]+iif((t mod 2=1)and(a[y][x]=1),(t div 2)+1,t div 2);if y<h then b[y+1][x]:=b[y+1][x]+iif((b[y][x]mod 2=1)and(a[y][x]=0),(t div 2)+1,t div 2);end;for Y:=0to h do for X:=0to w do if b[y][x]mod 2=1then a[y][x]:=iif(a[y][x]=1,0,1);y:=0;x:=0;repeat a[y][x]:=iif(a[y][x]=1,0,1);if a[y][x]=1then inc(y) else inc(x);until(y>h)or(x>w);write(Format('%d %d',[y,x]));end.

Ungolfed

uses
  SysUtils,Classes,idglobal;
var
  a:TArray<TArray<byte>>;
  b:TArray<TArray<int64>>;
  h,w,x,y,t:int16;
  n:int64;
  s:string;
  r:TStringList;
  tra:byte;
begin
  r:=TStringList.Create;
  readln(h,w,n);
  h:=h-1;w:=w-1;
  for y:=0to h do
  begin
    readln(s);
    r.Add(StringReplace(s,' ','',[rfReplaceAll]));
  end;
  SetLength(a,h);
  SetLength(b,h);
  for y:=0to h do
  begin
    SetLength(a[y],w);
    SetLength(b[y],w);
    for x:=1to Length(r[y])do
      a[y][x-1]:=Ord(r[y][x])-48;
  end;
  b[0][0]:=n-1;
  for Y:=0to h do
    for X:=0to w do
    begin
      t:=b[y][x];
      if x<w then
        b[y][x+1]:=b[y][x+1]+iif((t mod 2=1)and(a[y][x]=1),(t div 2)+1,t div 2);
      if y<h then
        b[y+1][x]:=b[y+1][x]+iif((b[y][x]mod 2=1)and(a[y][x]=0),(t div 2)+1,t div 2);
    end;
  for Y:=0to h do
    for X:=0to w do
      if b[y][x]mod 2=1then
        a[y][x]:=iif(a[y][x]=1,0,1);
  y:=0;x:=0;
  repeat
    a[y][x]:=iif(a[y][x]=1,0,1);
    if a[y][x]=1then
      inc(y)
    else
      inc(x);
  until(y>h)or(x>w);
  write(Format('%d %d',[y,x]));
end.

Comments

आपको मेरा वोट अभी तक नहीं मिला है। मैं रात का खाना खा रही थी। (अपवित्र)

— johnchen902

Answer 5

सी ++ 213 बाइट्स * 0.5 = 106.5

यहाँ मेरा समाधान है। यह user2357112 के समाधान के समान है , लेकिन इसमें कई अंतर हैं:

• पहले, मैं ऊपर और बाएं से गणना करने के बजाय, दाएं और नीचे जाने का समय भेज देता हूं ।
• दूसरा, मैं सब कुछ करता हूं (इनपुट पढ़ना, प्रेषण, आदमी के स्थान को ट्रैक करना) एक साथ।
• तीसरा, मैं स्मृति की केवल एक पंक्ति रखता हूं।

#include <iostream>
int o[1001],h,w,r,c,i,j,t,u;int main(){std::cin>>h>>w>>*o;for(;i<h;i++)for(j=0;j<w;)std::cin>>t,u=o[j],o[j]/=2,u%2&&o[j+t]++,r-i|c-j||((u+t)%2?r:c)++,o[++j]+=u/2;std::cout<<r<<" "<<c<<"\n";}

यहाँ ungolfed संस्करण है:

#include <iostream>
using namespace std;
int o[1001];
int main(){
    int h, w, n;
    cin >> h >> w >> n;
    o[0] = n;
    int r = 0, c = 0;
    for(int i = 0; i < h; i++)
        for(int j = 0; j < w; j++){
            bool t;
            cin >> t;
            int u = o[j];
            o[j + 1] += u / 2;
            o[j] = u / 2;
            if(u % 2)
                (t ? o[j + 1] : o[j])++;
            if(r == i && c == j)
                ((u + t) % 2 ? r : c)++;
        }
    cout << r << " " << c << endl;
}

Comments

ये तीन अंतर चीजों को बहुत परेशान करते हैं। हम अनुक्रमण को छोटा कर सकते हैं और कई अनावश्यक डेटा संरचनाओं को जोड़ सकते हैं। यात्राओं को आगे बढ़ाने के लिए तर्क पिछले कोशिकाओं से यात्राओं को खींचने के तर्क से बहुत कम हो जाता है। क्षैतिज सीमा शर्तों को केवल डेटा संरचना को दाईं ओर एक अतिरिक्त स्थान प्रदान करके नियंत्रित किया जाता है, और ऊर्ध्वाधर सीमा की स्थिति कोई समस्या नहीं है।

— user2357112

मैंने आपके उत्तर को बदल दिया है और अवधारणाओं को अपने कोड में शामिल कर लिया है। अब तक, उन्होंने मेरे समाधान में से 84 बाइट्स ले लिए हैं, 30% का सुधार।

— user2357112

मुझे संदेह है कि आप कुछ बाइट्स को नहीं करने में सक्षम हो सकते हैं --*o;, और इसके बजाय स्विच करें कि आप किस मामले को नीचे ले जाते हैं और किस मामले में आप लड़के को दाईं ओर ले जाते हैं।

— user2357112

@ user2357112 कार्यान्वित किया गया, लेकिन पिछली गलती के कारण कोड की लंबाई बढ़ गई (यह 218 बाइट्स होना चाहिए)।

— जॉनचेन 902

Answer 6

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

कोड गोल्फिंग में मेरा पहला प्रयास कभी भी, अगर मुझे यहाँ कुछ गलत लगा हो तो क्षमा करें! User2357112 के कोड के आधार पर इनपुट को हथियाने के लिए कोड का उपयोग किया जाता है।

l=lambda:map(int,raw_input().split())
h,w,n=l()
m=[l() for i in[1]*h]
while n>0:
 n-=1;x=y=0
 while x!=w and y!=h:
  if m[y][x]>0:m[y][x]=0;x+=1
  else:m[y][x]=1;y+=1
print y,x

इनपुट:

3 4 3
1 0 1 1
0 1 0 0
1 0 1 0

आउटपुट:

0 4

Answer 7

आर, 196 बाइट्स * 0.5 = 98

f=function(h,w,n,x){I=J=rep(1,n);for(i in 1:h)for(j in 1:w){M=which(I==i&J==j);N=length(M);if(N){z=seq(1,N,by=2);if(x[i,j])z=-z;f=M[-z];s=M[z];I[f]=i;J[f]=j+1;I[s]=i+1;J[s]=j}};cat(I[n]-1,J[n]-1)}

Ungolfed:

f=function(h,w,n,x) {
  I = J = rep(1,n)

  for(i in 1:h) for(j in 1:w) {
    M = which(I==i&J==j)
    N = length(M)
    if (N) {
      z = seq(1,N,by=2)
      if (x[i,j]) z = -z
      f = M[-z]
      s = M[z]
      I[f] = i
      J[f] = j+1
      I[s] = i+1
      J[s] = j
    }
  }
  cat(I[n]-1, J[n]-1)
}

उपयोग:

f(3,4,4,matrix(c(1,0,1,0,1,0,1,0,1,1,0,0),3))
3 2