गुरुत्वाकर्षण सिम्युलेटर

33

बयान

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

ग्रिड के अंदर तत्व

  • - फर्श, गिरने वाली गेंदों की दिशा में परिवर्तन नहीं करता है।
  • \ राइट स्लाइड, बॉल वन (1) की पोजीशन को दाईं ओर मोड़ती है।
  • / बाईं ओर स्लाइड, एक गेंद (1) की स्थिति के पथ को बदल देती है।
  • o एक गेंद।

नियम

  • बॉल्स गिर जाते हैं।
  • फर्श, और स्लाइड नहीं गिरते हैं ।
  • यदि गेंद एक स्लाइड को हिट करती है जो इसे दीवार ( \#या #/) के माध्यम से जाती है, या एक मंजिल के माध्यम से पार करती है तो स्लाइड एक मंजिल के रूप में कार्य करेगी।
  • जब एक गेंद दूसरी गेंद को मारती है, तो एक ही गेंद बनेगी, लेकिन दोनों गेंदों के योग में अपनी शक्ति बढ़ाएगी।
  • नई गेंदों (शामिल) हमेशा की तरह व्यवहार करना जारी रखेंगी।
  • जब कोई गेंद अब आगे नहीं बढ़ सकती है, तो इसे अपनी शक्ति से बदल दिया जाता है।
  • एक गेंद की शक्ति हमेशा अधिकतम 9 पर होगी।

इनपुट

ग्रिड को आपकी पसंद की भाषा में जो भी नाम सबसे छोटा है, एक स्ट्रिंग चर में दिया जाएगा। डिफ़ॉल्ट रूप से हम aइनपुट के रूप में उपयोग करेंगे। एक इनपुट का एक नमूना, बिल्कुल प्राप्त के रूप में:

##########\n# \      #\n#o       #\n#  - -\o #\n#/-    \ #\n#  \oo-/\#\n#-/ \   /#\n#   \ \  #\n#       /#\n##########

उत्पन्न ग्रिड के लिए यादृच्छिक उपयोग https://repl.it/B1j3/2 । इसके बजाय मेरे जनरेट किए गए पृष्ठ का उपयोग करें (कोई विज्ञापन नहीं, कोई बकवास नहीं, बस इनपुट और आउटपुट)

नोट लाइन ब्रेक हैं \n। स्क्रीन पर इनपुट प्रिंट करना (चुनौती के लिए आवश्यक नहीं) इस तरह की चीजें दिखाएगा। हालांकि मैंने चार पहेलियाँ सुरक्षित स्थान के साथ लगाई हैं।

##########  ##########  ##########  ##########
# \      #  # o    -/#  #       o#  #-o /    #
#o       #  #    \   #  # o     -#  #-- \ /\ #
#  - -\o #  #-  \    #  #    - \o#  # - -- o-#
#/-    \ #  #        #  #o /\    #  #/ \     #
#  \oo-/\#  #o  -o-  #  # /    -o#  #/ /o oo/#
#-/ \   /#  #   -/-  #  # -  o  -#  #o/      #
#   \ \  #  #    \\  #  #   \o  /#  #o-o    o#
#       /#  # \o\  /\#  #     \o #  # -\o o /#
##########  ##########  ##########  ##########

उत्पादन

वही ग्रिड, जिसे बॉल पॉवर के अंतिम परिणाम के साथ स्क्रीन पर प्रिंट किया जाता है। एक मान्य उत्तर निम्नलिखित पहेलियों में से एक (1) होगा, प्रत्येक एक ही स्थिति में इनपुट से मेल खाती है, यदि इनपुट अलग है तो आपको आउटपुट समायोजित करना चाहिए। इसे उन चार तक सीमित न करें!

##########  ##########  ##########  ##########
# \      #  #      -/#  #       1#  #-1 /    #
#        #  #    \   #  #       -#  #-- \ /\ #
#1 - -\  #  #-  \    #  #    - \ #  # - --  -#
#/-    \1#  #        #  #  /\    #  #/ \     #
#  \  -/\#  #   -1-  #  # /    -2#  #/ /    /#
#-/ \   /#  #   -/-  #  # -     -#  # /      #
#   \ \  #  #    \\  #  #   \   /#  # -      #
#    2  /#  #1\2\  /\#  #2   2\1 #  #2-\3 23/#
##########  ##########  ##########  ##########

स्कोर

भाषाएं खुद के खिलाफ प्रतिस्पर्धा करेंगी ताकि नोंगोल्फ भाषाओं का उपयोग करने के लिए स्वतंत्र महसूस हो। एक समाधान को मान्य करने के लिए मुझे इसे काम करने के लिए कहीं और परीक्षण करने में सक्षम होना चाहिए!

स्कोर बाइट्स की संख्या है। एक टाई होने की स्थिति में, बंधा हुआ स्कोर जीत तक पहुंचने का पहला उत्तर है।

चेतावनी

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

गेंद आंदोलन के स्पष्ट उदाहरण

######                       ######
#-o- #    BALL WOULD GO RD   #- - #
# \  #                       # \o #
######                       ######

######                       ######
#-o- #     BALL WOULD STAY   #-o- #
# \\ #                       # \\ #
######                       ######

######                       ######
#  -o#     BALL WOULD STAY   #  -o#
#   \#                       #   \#
######                       ######

######                       ######
#  o #     BALL WOULD STAY   #  o #
#  \/#                       #  \/#
######                       ######

######                       ######
#-o- #    BALL WOULD GO LD   #- - #
# /\ #                       #o/\ #
######                       ######

अद्यतन

यदि मेरा उत्तर मान्य है तो मैं कैसे परीक्षण कर सकता हूं?

मैंने अपनी एक साइट में एक सरल पृष्ठ स्थापित किया है जो आपको एक यादृच्छिक पहेली देगा, और इसका उत्तर। इनपुट लें और इसे आउटपुट के खिलाफ जांचें। गोल्फ के बारे में बहुत ज्यादा चिंता किए बिना मेरा समाधान, अजगर (जनरेटर, और पेज भी अजगर) में है389b 355b

लीडरबोर्ड

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

code-golf  ascii-art  grid  simulation 
— जुआन कोर्टेस
स्रोत
1
मुझे मारबेलस की याद आई ।
— आर्कटिकस
10
बोनस अंक अगर किसी को मारबुलस में जवाब देता है।
— Mego
— पीटर टेलर
संभावित रूप से
— अस्सी
@ JuanCortés आप फैंसी लीडर बोर्ड कोड का उपयोग क्यों नहीं करते हैं ताकि आपको खुद रैंकिंग अपडेट न करनी पड़े?
— usandfriends 16

जवाबों:

6

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

पंक्ति द्वारा पंक्ति के बजाय चार द्वारा संपादित करें , बेहतर परिणाम

g=>(s=~g.search`
`,g=[...g]).map((c,i)=>c<' '?0:g[[0,1,-1].map(d=>!d|'\\ /'[d+1]==g[d+=i]&&+g[d+=s]?g[v+=+g[d],d+v-v]=' ':0,v=c>'a'?1:+c),i]=v?v:c)&&g.join``

नोट: गेंद के मूल्यों को नहीं संभालता है 9. 9. लेकिन यह 18 बाइट की लागत के साथ हो सकता है। नीचे बुनियादी कोड देखें।

टेस्ट स्निपेट (बेहतर पूर्ण पृष्ठ)

F=g=>(s=~g.search`
`,g=[...g]).map((c,i)=>c<' '?0:g[[0,1,-1].map(d=>!d|'\\ /'[d+1]==g[d+=i]&&+g[d+=s]?g[v+=+g[d],d+v-v]=' ':0,v=c=='o'?1:+c),i]=v?v:c)&&g.join``

// Basic code, starting point before golfing
B=g=>{
  s = ~g.search('\n');
  (g=[...g]).map((c,i)=>{
    v = c == 'o' ? 1 : +c
    if (c>=' ' // skip newlines
        && !isNaN(v)) // digit or space
    {
      if (w=+g[i+s]) v += w, g[i+s]=' '
      if (g[i-1]=='\\' && (w=+g[i+s-1])) v += w, g[i+s-1]=' '
      if (g[i+1]=='/' && (w=+g[i+s+1])) v += w, g[i+s+1]=' '
      if (v) g[i] = v
    }
  })      
  // return g.join``
  // To handle values > 9 ...
  return g.map(v=>+v?v%10:v).join``
}  

function test() {
  O.textContent = F(I.value)
}

test()
textarea,pre { width: 15em; height: 15em; display: block; margin: 0; }
iframe { height: 25em; width: 15em}
td { vertical-align: top }
<table>
  <tr>
    <th>Test cases</th>
    <th>Input</th>
    <td></td>
    <th>Output</th>
  </tr><tr>
    <td>
    Copy/paste test cases from here <br>(courtesy of OP)
    <button onclick="T.src='http://bohem.io/wadus/index.php'">reload</button><br>
    <iframe id=T src="http://bohem.io/wadus/index.php"></iframe>
    </td>
    <td><textarea id=I>##########
#  o  o o#
# o\o o  #
#oo o/   #
#       o#
#     /o #
#\o   o  #
# o /-   #
#   o  - #
##########</textarea></td>
    <td><button onclick='test()'>Test</button></td>
    <td><pre id=O></pre></td>
  </tr>
</table>
स्निपेट का विस्तार करें

— edc65
स्रोत
अच्छा! मुझे गोल्फ के तरीके सीखने के लिए बहुत कुछ है
— usandfriends
आपको मान> 9 के साथ मैप नहीं करना चाहिए v>9?9:v?
— टाइटस
@Titus मैं कर सकता था, लेकिन वास्तव में मैं जो कुछ भी कर सकता था, मूल्य के रूप में> 9 की उम्मीद नहीं है, ओपी द्वारा मेरे प्रश्न का उत्तर देते हुए टिप्पणी देखें।
— edc65
5

जावास्क्रिप्ट (ईएस 6), 453 426 409 306 290 286 बाइट्स

मेरे दिमाग में आया पहला और सबसे स्पष्ट समाधान वह है जो स्लाइड के चारों ओर दिखता है और फिर विलीन हो जाता है या बदल जाता है।

a=>{a=a.split`
`.map(b=>[...b.replace(/o/g,'1')]);for(r=1;r<a.length-1;r++){d=a[r];for(c=1;c<d.length-1;c++){e=a[r+1];f=e[c]=='\\'?c+1:e[c]=='/'?c-1:!isNaN(+e[c])?c:null;(''+d[c]).match(/[0-9]/g)&&f!=null&&!isNaN(+e[f])?(e[f]=+e[f]+ +d[c],d[c]=' '):0}}return a.map(b=>b.join``).join`
`}

Ungolfed:

func = state => {
    state = state.split `
`.map(line => [...line.replace(/o/g, '1')]);

    for (r = 1; r < state.length - 1; r++) {
        thisState = state[r];
        for (c = 1; c < thisState.length - 1; c++) {
            nextState = state[r + 1];
            nc = nextState[c] == '\\' ? c + 1 : nextState[c] == '/' ? c - 1 : !isNaN(+nextState[c]) ? c : null;

            ('' + thisState[c]).match(/[0-9]/g) && nc != null && !isNaN(+nextState[nc]) ? (
                nextState[nc] = +nextState[nc] + +thisState[c],
                thisState[c] = ' '
            ) : 0;
        }
    }

    return state.map(line => line.join ``).join `
`;
}

टेस्ट जैसे:

func(`##########
# -- o - #
# \\\\\\ -  #
#-       #
# o  o   #
#o \\\\ /-\\#
#      \\ #
#/-  //  #
#   /- o #
##########`)

आभार: @ edc65

— usandfriends
स्रोत
मैं अपने अजगर को पोस्ट करूँगा जब मुझे यकीन है कि मैं इसे अब और गोल्फ नहीं कर सकता, लेकिन अभी तक यह अजगर कोड है जो जवाब पैदा कर रहा है। किसी भी तरह से मैं कहीं आपके गोल्फ कोड का परीक्षण कर सकता हूं ताकि मैं आपको लीडरबोर्ड पर पॉप कर सकूं? (jsfiddle, jsbin, ideone, जो भी हो)
— Juan Cortés
इसे 355 पर ले जाएं, आपकी चाल!
— जुआन कोरटेस
@ JuanCortés हो गया!
— usandfriends
b.replace(/o/g,'1').split`` को छोटा किया जा सकता है[...b.replace(/o/g,1)]
— edc65
@ edc65 मुझे लगता है कि मैंने इसे ठीक कर लिया है। मूल रूप से यह हमेशा 10 से कम की शक्ति रखता है। मोडिंग 10.
— usandfriends
4

जावा, बहुत सारे 1102 987 बाइट्स

क्योंकि, जावा।

\ o / यह 1000 से कम है!

class G{class T{char s;int p=0;T(char c){s=c;}}T A=new T(' ');T[][]o;boolean i(){for(int i=1;i<o.length;i++)for(int j=1;j<o[i].length;j++)if(o[i][j].p>0){if(m(i,j,i+1,j)||o[i+1][j].s=='/'&&m(i,j,i+1,j-1)||o[i+1][j].s=='\\'&&m(i,j,i+1,j+1))return 1>0;int w=o[i][j].p;o[i][j]=new T(Integer.toString(w).charAt(0)){{p=w;}};}return 1<0;}boolean m(int a,int b,int c,int d){if(o[c][d]==A||o[c][d].p>0){o[a][b].p+=o[c][d].p;o[c][d]=o[a][b];o[a][b]=A;return 1>0;}return 1<0;}String s(){String s="";for(T[]r:o){for(T t:r)s+=t.s;s+="\n";}return s;}void f(String s){String[]r=s.split("\\\\n");o=new T[r.length][r[0].length()];for(int i=0;i<o.length;i++)for(int j=0;j<o[i].length;j++)switch(r[i].charAt(j)){case'-':o[i][j]=new T('-');break;case'\\':o[i][j]=new T('\\');break;case'/':o[i][j]=new T('/');break;case'o':o[i][j]=new T('o'){{p=1;}};break;case'#':o[i][j]=new T('#');break;default:o[i][j]=A;}}public static void main(String[]a){G g=new G();g.f(a[0]);while(g.i());System.out.println(g.s());}}

एक साइड गोल बोर्ड के प्रत्येक पुनरावृत्ति को प्रिंट करने में सक्षम हो रहा था: बस बीच ;में हटा दें while(g.i()) ; System.out.print(g.s());(हालांकि यह अंतिम प्रिंट को निष्क्रिय करता है जिसमें 0-> शक्ति रूपांतरण है)। दुर्भाग्य से, इस संस्करण में, गुरुत्वाकर्षण अजीब तरीके से काम करता है। प्रत्येक पास मैं पहली गैर-अटकी गेंद लेता हूं और इसे स्थानांतरित करता हूं। लघु सर्किटिंगiterate() पूरे बोर्ड पर जाने की तुलना में कम बाइट्स है, अगर कुछ भी बदला तो वापस लौटना।

यह एक पूर्ण मुख्य वर्ग है, तर्क के साथ कमांड लाइन पर संकलित करें और चलाएं:

java -jar G.jar "##########\n# o-/    #\n#-  / -/ #\n# oo   o #\n# /   \o #\n# o   o \#\n#    o   #\n#   -\o  #\n#\  \\ o/#\n##########"

"पठनीय" संस्करण:

class GravitySimulator {
    class Token {
        char symbol;
        int power = 0;

        Token(char c) {
            symbol = c;
        }
    }

    Token A = new Token(' ');

    Token[][] board;

    boolean iterate() {
        for (int i=1; i<board.length; i++)
            for (int j=1; j<board[i].length; j++) 
                if (board[i][j].power>0) {
                    if (move(i,j,i+1,j) || board[i+1][j].symbol=='/' && move(i,j,i+1,j-1) || board[i+1][j].symbol=='\\' && move(i,j,i+1,j+1)) return true;
                    int pow = board[i][j].power;
                    board[i][j] = new Token(Integer.toString(pow).charAt(0)){{power=pow;}};
                }
        return false;
    }

    boolean move(int x1, int y1, int x2, int y2) {
        if (board[x2][y2] == A || board[x2][y2].power>0) {
            board[x1][y1].power += board[x2][y2].power;
            board[x2][y2] = board[x1][y1];
            board[x1][y1] = A;
            return true;
        } return false;
    }

    String string() {
        String s = "";
        for (Token[] row : board) {
            for (Token token : row) s+=token.symbol;
            s+="\n";
        }
        return s;
    }

    void fromString(String s) {
        String[] rows = s.split("\\\\n");
        board = new Token[rows.length][rows[0].length()];
        for (int i=0; i<board.length; i++) 
            for (int j=0; j<board[i].length; j++) 
                switch(rows[i].charAt(j)) {
                    case '-': board[i][j]=new Token('-');break;
                    case '\\':board[i][j]=new Token('\\');break;
                    case '/': board[i][j]=new Token('/');break;
                    case 'o': board[i][j]=new Token('o'){{power=1;}};break;
                    case '#': board[i][j]=new Token('#');break;
                    default:  board[i][j]=A;
                }
    }

    public static void main(String[] args) {
        GravitySimulator g = new GravitySimulator();
        g.fromString(args[0]);
        while(g.iterate());
        System.out.println(g.string());
    }
}
— CAD97
स्रोत
ऐसे जावा बहुत क्रिया। +1
— रोहन झुनझुनवाला
0

PHP, 228 204 197 194 बाइट्स

for($a=strtr($a,o,1);$c=$a[$i];$i++)$c>0&&(($d=$a[$t=$i+strpos($a,"
")+1])>" "?$d!="/"?$d!="\\"?$d>0:$a[++$t]<"!"||$a[$t]>0:$a[--$t]<"!"||$a[$t]>0:1)&&$a[$t]=min($a[$t]+$c,9).!$a[$i]=" ";echo$a;

PHP 7.1 में चेतावनी देता है। ठीक करने (int)से पहले डालें $a[$t]+$c।

इसे ऑनलाइन चलाएं php -nr '$a="<string>";<code>'या इसके लिए प्रयास करें ।

टूट - फूट

for($a=strtr($a,o,1);   # replace "o" with "1"
    $c=$a[$i];$i++)     # loop through string
    $c>0                    # if character is numeric
    &&(($d=$a[                  # and ...
        $t=$i+                  # 3: target position = current position + 1 line
            strpos($a,"\n")+1   # 2: width = (0-indexed) position of first newline +1
    ])>" "                  # if target char is not space
        ?$d!="/"                # and not left slide
        ?$d!="\\"               # and not right slide
        ?$d>0                   # but numeric: go
        :$a[++$t]<"!"||$a[$t]>0     # right slide: if target+1 is space or ball, then go
        :$a[--$t]<"!"||$a[$t]>0     # left slide: if target-1 is space or ball, then go
    :1                              # space: go
    )&&                     # if go:
        $a[$t]=min($a[$t]+$c,9) # move ball/merge balls
        .!$a[$i]=" "            # clear source position
    ;
echo$a;                 # print string
— टाइटस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.