एक विमान पर वैध सांप

Question

वी हार्ट के वीडियो में से एक से प्रेरित (जो संभावित चुनौती विचारों से भरा खजाना है)

एक सांप एक ही लंबाई के खंडों से बना होता है और प्रत्येक खंड के बीच का संबंध सीधा हो सकता है या 90 ° मोड़ सकता है।
हम इस तरह के सांप (एक रोटेशन तक, जो कि प्रारंभिक दिशा पर निर्भर करता है) को थोड़ा नीचे लिखकर बदल सकते हैं, जिस दिशा में वह मुड़ता है (सीधे / बाएं / दाएं)। यह एक, ऊपर बाईं ओर शुरू होता है और दाईं ओर इंगित करता है

-+    +--+    SR    RSSR
 |  +-+  |     S  RSL  S
 +--+  --+     LSSL  SSR

द्वारा प्रस्तुत किया जाएगा SRSLSSLRLRSSRSRSS

और निश्चित रूप से एक प्लेनर सांप अपने आप को (जैसे SSSSLLLSS) को काट नहीं सकता है , जिसके परिणामस्वरूप एक भयानक पिक्सेलेटेड गेम ओवर होगा।

आपका कार्य यह निर्धारित करना है कि कोई वैध है या नहीं (कम से कम एक आत्म-प्रतिच्छेदन के परिणाम)

इनपुट
एक स्ट्रिंग आउटपुट से कुछ के SLRसाथ सत्य कुछ अगर यह एक वैध है और कुछ झूठी अगर यह नहीं है।2 < length < 10000

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

__Valid__
SSLSLSRSRSSRSSSLLSSSRRLRSLRLLSSS
SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR (A hilbert curve)
RLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRR
SRRSRSRSSRSSRSSSRSSSRSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS (Spiral)
SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS (bigger, squigglier spiral)
LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLL

__Invalid__
SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR
SRRLSLLRRLLSLRRSRLLRSRRLLSRSSSRSSSSSSSRSRSSSSSSSRRLLRRSRLLRSRRLSLLRRLLSLRR
SRRSRSRSSRSSRSSSRSSSRSSSSSSSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS
SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLRLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS
LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLLSLRLSLRSLRSLRSLSLSLRSRLSLRSLRLSRSLLLRLRLRRRRSLSLSSLLSLSLSLSSLLSLSLLRLRSLLRSRLSLSSLLLLSSSSSSSSSSSSSSSSSSSSRLRLLRRLRLRLLRLRLRLRLRLSSSSLSLRLLRLSLSSLSLSLSLSLRLLRLSLLLSRSSSSSSSSSSSSSSSRLRLRLLRLRLSLSRSRSSSLSRLRLRLRSLSLSLSRLLSRLSLSLSLSLSSLSLSLLSLSRLLRLRLRLRLRLRLRLRLRLRLSLSRLRLSLLRRLSLLSLSLSLSLSLLSLSLSLRLRLRLRLRLRLRLRLRLRRLRSLSLSLSLSLSLSLSSLSSSSSLSLSSSLSLSLSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS

आप यहाँ कातिलों को आकर्षित कर सकते हैं (आर और एल फ़्लिप किए जाते हैं, लेकिन यह वैधता को प्रभावित नहीं करता है)

Comments

क्या कार्यक्रम में इनपुट करना पड़ता है या इसे किसी फ़ाइल से पढ़ा जा सकता है?

— एमआई राइट

SRRR सही होना चाहिए या गलत? यह जोड़ता है, लेकिन खुद को नहीं काटता है।

— or

छूना सांपों को चुनौती NSFW?

— इवान

यदि आप SRRRएक वर्ग प्रति खंड के साथ एक ग्राफ पेपर पर आकर्षित करते हैं, तो यह ओवरलैप होगा और इसलिए अमान्य है, बस RRR, हालांकि,

— ओवरलैप्स के

समान लेकिन एक डुप्लिकेट नहीं (विभिन्न उद्देश्य और विभिन्न निर्माण नियमों के कारण)।

— ट्राइकोप्लेक्स 20

Answer 1

पायथ, 22 20 बाइट्स

ql{m+=Z*=T^.j)hCdzlz

इसे स्वयं आज़माएं या टेस्टसुइट चलाएं ।

क्रमश: 83, 76, 82, SRL के ASCII मूल्यों पर ध्यान दें। मैं इस तथ्य का दुरुपयोग करता हूं कि:

i ^{83 + 1} = 1
i ^{76 + 1} = i
i ^{82 + 1} = -i

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

अंत में मैं जांचता हूं कि क्या सभी विज़िट किए गए स्थान अद्वितीय हैं।

Comments

SRRR = सच ????

— इवान

@ ईवान निकट निरीक्षण पर - मुझे यकीन नहीं है कि यह गलत होना चाहिए या नहीं। सिर और पूंछ कनेक्ट होते हैं, लेकिन अंतरंग नहीं होते हैं।

— or

SRRRS के बारे में क्या?

— इवान

@ ईवन समान कहानी - कनेक्शन लेकिन कोई चौराहा नहीं। सवाल स्पष्ट नहीं है कि इन के लिए क्या लौटाया जाना चाहिए।

— orlp

आप SRRR कैसे आकर्षित करेंगे?

— इवांका

Answer 2

सीजेएम, 30 बाइट्स

q{iF%U+:U[XWe4W1e4]=T+:T}%__&=

जल्द ही पालन करने के लिए स्पष्टीकरण।

इसे यहां ऑनलाइन आज़माएं या पूरे सुइट को चलाएं ।

Comments

धिक्कार है, कि तेज था। मैंने अभी तक इसे हल करने के लिए एक एल्गोरिथम के बारे में नहीं सोचा था।

— डेनडेनडो

SRRRS = सच ???

— इवान

@ ईवन उम्म, क्या हम मान रहे हैं कि शुरू में 0 भरा हुआ है और मायने रखता है?

— ऑप्टिमाइज़र

मुझे लगता है कि मैं इसे सांप के खेल की तरह व्याख्या कर रहा हूं, जहां कदम अंतरिक्ष के ब्लॉक लेते हैं। और आप में से कुछ लोग इसे एक शून्य चौड़ाई रेखा के रूप में व्याख्या कर रहे हैं

— इवान

@ इवान मेरा सवाल हालांकि थोड़ा अलग है। जब हमारे पास एक कदम होता है, तो कहते हैं S, क्या इसका मतलब है कि सांप ने पहले ही दोनों (0,0) और (1,0) पर कब्जा कर लिया है?

— ऑप्टिमाइज़र

Answer 3

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

परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ।

कुछ नोट:

• साँप f सरणी के अंदर चलता है। परिकल्पित कोशिकाओं का मूल्य है undefined। पहली यात्रा पर, टिल्ड ऑपरेटर इसे -1 में बदल देता है जो एक सत्य है। आखिरकार, दूसरी यात्रा के लिए मान 0 में बदल जाता है जो मिथ्या है औरevery झूठा है लूप झूठी वापस लौटता है।
• जेएस में, गैर कैन्योनिक सूचकांकों (संख्यात्मक या नकारात्मक नहीं) वाले सरणी तत्व किसी तरह 'छिपे' हैं, लेकिन वे मौजूद हैं। यहां मैं बिना किसी समस्या के नकारात्मक सूचकांकों का उपयोग करता हूं।

F=s=>[...s].every(c=>f[p+=[1,1e5,-1,-1e5][d=d+{R:1,L:3,S:0}[c]&3]]=~f[p],d=p=0,f=[])

//TEST
$('#S').on('keyup mouseup change', Draw);

function Draw(){
  var s = S.value.toUpperCase();
  if (!s) {
    C.width = C.height = 0;
    return
  }
  C.width = 600;
  C.height = 400;
  
  var ctx = C.getContext("2d");  
  var px, py, int=0;
  
  ctx.strokeStyle = '#008';
  ctx.lineWidth = 2;
  ctx.translate(300,200);
  ctx.beginPath();
  ctx.moveTo(0,0);
  
  [...s].forEach(c=>{
    (f[p+=[1,1e4,-1,-1e4][d=d+{R:1,L:3,S:0}[c]&3]]=~f[p])
    ? 1 
    : (++int)
    if (int==1) ctx.stroke(), ctx.strokeStyle = '#800', ctx.beginPath(), ctx.moveTo(10*px,10*py);
    
    py = (p / 1e4 | 0) - 5e3;
    px = (p % 1e4) -5e3
    ctx.lineTo(10*px, 10*py);
  }, d=0,p=50005000,f=[]);
  ctx.stroke();
  
}

valid=["SSLSLSRSRSSRSSSLLSSSRRLRSLRLLSSS",
"SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR",
"RLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRRSRLLRSRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLSSLLRSRRLLRR",
"SRRSRSRSSRSSRSSSRSSSRSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS",
"SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS",
"LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLL"];
invalid=["SRRLSLLRRLLSLRRSRLLRSRRLLRRSRLLLLRSRRLLRRSRLLRSRRLSLLRRLLSLRR",
"SRRLSLLRRLLSLRRSRLLRSRRLLSRSSSRSSSSSSSRSRSSSSSSSRRLLRRSRLLRSRRLSLLRRLLSLRR",
"SRRSRSRSSRSSRSSSRSSSRSSSSSSSSSSRSSSSRSSSSSRSSSSSRSSSSSSRSSSSSSRSSSSSS",
"SSSSSSSSSSLSSSSSSSLSSSSSSSSLSSSSSLSSSSSSLSSSLLRRLRLRRLLSLSSSRRSSSSRSSSRSSSSSSRSSSSSRSSSSSSSSRSSSSSSSRSSSSSSSSS",
"LRSLLRLSRSLLSRLSLRSLSSSLRRSSLSRRLRSRLRLSLRLLRLRSSLSLRLRSRSSSSSLSRRLSLSSSRRLRLRLRLRRLLSSLSSSRRLRLRLRLRLSLSSSSSSSSSSSSSRLRLLRLRLRLRLRLRLRLSLSSSLSLSLLSLRLSLRSLRSLRSLSLSLRSRLSLRSLRLSRSLLLRLRLRRRRSLSLSSLLSLSLSLSSLLSLSLLRLRSLLRSRLSLSSLLLLSSSSSSSSSSSSSSSSSSSSRLRLLRRLRLRLLRLRLRLRLRLSSSSLSLRLLRLSLSSLSLSLSLSLRLLRLSLLLSRSSSSSSSSSSSSSSSRLRLRLLRLRLSLSRSRSSSLSRLRLRLRSLSLSLSRLLSRLSLSLSLSLSSLSLSLLSLSRLLRLRLRLRLRLRLRLRLRLRLSLSRLRLSLLRRLSLLSLSLSLSLSLLSLSLSLRLRLRLRLRLRLRLRLRLRRLRSLSLSLSLSLSLSLSSLSSSSSLSLSSSLSLSLSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS"];

V.innerHTML=valid.map(s=>F(s)+' '+s).join('\n')
I.innerHTML=invalid.map(s=>F(s)+' '+s).join('\n')

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
Type to check and draw <input id=S>
(better full page)<br>
<canvas id=C width=1 height=1 ></canvas><br>
Valid<pre id=V></pre>
Invalid<pre id=I></pre>

Answer 4

टीआई-बेसिक, 49 56 53 51 बाइट्स

abs(e^(i)-cumSum(i^cumSum(seq(inString("SL",sub(Ans,X,1))-1,X,1,length(Ans→X
SortA(∟X
min(ΔList(∟X

ऑरलपी की विधि के समान, यह मूल में शुरू होने वाले साँप द्वारा दौरा किए गए जटिल विमान में सभी बिंदुओं की एक सूची बनाता है। यदि सूची में कोई डुप्लिकेट तत्व नहीं हैं, तो कोड कुछ सकारात्मक मान लौटाता है। ध्यान दें कि 999 से अधिक तत्वों की एक स्ट्रिंग पर, कैलकुलेटर एक पर्याप्त लंबी सूची उत्पन्न करने में असमर्थ होगा, और त्रुटि करेगा।

संपादित करें: कुरूपता की कीमत पर दो बाइट्स को बचाया क्योंकि जटिल विमान पर कोई दो जाली बिंदु ई ^ i से समान दूरी पर हो सकते हैं।

Answer 5

टीआई-बेसिक, 60 58 बाइट्स

संपादित करें: नीचे दी गई हर चीज को नजरअंदाज करें: एक कामकाजी ती-बुनियादी समाधान यहां है , थोमस-क्वा द्वारा। कि ऊपर जाना!

⁻है [(-)]कुंजी है, और उत्तर है [2ND]->[(-)]। सांप के निर्देशों को उद्धरणों में संलग्न करके इसे चलाएं ( [ALPHA]->[+]) इसके बाद एक बृहदान्त्र और फिर प्रोग्राम का नाम। उदाहरण के लिए, यदि आप "SNAKE" प्रोग्राम का नाम रखते हैं, तो आप ओपी में परीक्षण मामले को चलाएंगे "SRSLSSLRLRSSRSRSS":prgmSNAKE।

seq(inString("SRL",sub("0"+Ans,I,1)),I,1,length(Ans
Disp 0<sum(⁻1+2seq(Ans(I)≠(Ans(I-1),I,2,dim(Ans

संपादित करें: विफल रहता है SRRLSLLRRRS। मेरे पास 61 बाइट्स में एक संशोधित संस्करण है, लेकिन यह पहले अमान्य परीक्षण मामले में विफल रहता है:

seq(inString("SRL",sub("0"+Ans,I,1)),I,1,length(Ans
cumSum(⁻1+2seq(Ans(I)≠(Ans(I-1),I,2,dim(Ans
Disp 0<Ans(dim(Ans

मैं कल ठीक करने की कोशिश करूंगा।

---

अद्यतन: तो समस्या वास्तव में यह है कि मेरा एल्गोरिथ्म त्रुटिपूर्ण है। अगर मैंने seq (एक ही चीज़ को प्राप्त करने के लिए) के विपरीत (लूप के रूप में) का उपयोग किया था, तो यह (दोनों एल्गोरिदम ऊपर, वास्तव में) इस रूप में वर्णित किया जा सकता है:

1. काउंटर वैरिएबल को 1 पर प्रारंभ करें।
2. स्ट्रिंग पढ़ें। यदि प्रतीक बदलता है, तो काउंटर चर बढ़ाएँ। यदि प्रतीक दोहराता है, तो इसे घटाएं।
3. यदि काउंटर चर 0 से अधिक है, तो 1 (मान्य) प्रदर्शित करें। अन्यथा, 0 (अमान्य) प्रदर्शित करें।

हालाँकि, यह अमान्य स्लिटर्स जैसे विफल रहता है SRLRLRLRLRRRSS। अब मैं एक बेहतर एल्गोरिदम के साथ आने की कोशिश करूंगा ... या किसी अन्य उत्तर से चोरी करूंगा।

---

मुझे 90% यकीन है कि इसे seq(वास्तव में एक ही आदेश के साथ बदला जा सकता है , लेकिन अभी के लिए यह उतना छोटा है जितना मुझे मिल सकता है। यदि आप वास्तव में इसे टाइप करने के विरोध में Sourcecoder का उपयोग करते हुए इसे 8xp तक बनाने का इरादा रखते हैं, तो ध्यान दें कि ≠इसे बदल दिया जाना चाहिए !=और ⁻1+बिट को प्रतिस्थापित किया जाना चाहिए ~1+।

Answer 6

रूबी 87 89

F=->s{d=[1,w=1e4,-1,-w]
v=[w]+s.chars.map{|c|w+=d.rotate!(c<?R?-1:c>?R?0:1)[0]}
v==v&v}

ऑनलाइन टेस्ट: http://ideone.com/pepeW2

Ungolfed संस्करण:

F = -> input {
  # Coordinates are expressed using one number,
  # that is computed using the formula `y + x*max_x`.
  # Assume max horizontal field width (max_x) to be 10000,
  # since that's the max length of the input.
  position = max_x = 1e4

  # These are possible directions to move to (coordinate deltas).
  # The current direction is always the first in the array.
  directions = [1,max_x,-1,-max_x]

  visited = [position]

  visited += input.chars.map{|c|
    # adjust current direction...
    directions.rotate! case c
    when ?L
      -1
    when ?R
      1
    when ?S
      0
    end

    # ...and move there
    position += directions[0]
  }

  # Return `true` if `visited` only contains distinct elements, `false` otherwise
  visited == visited & visited
}

Answer 7

गोल्फस्क्रिप्ट 48 49 50

[10.4?:z-10z~)]z*z@{'R L S'?@>(@+.`n}%n/@;\;..&=

स्टैक पर मौजूद होने के लिए स्ट्रिंग की अपेक्षा करता है और 0या तो लौटता है 1।

आप इसे वैध और अमान्य साँपों के परीक्षण के साथ ऑनलाइन आज़मा सकते हैं।

यह मूल रूप से मेरे रूबी के उत्तर के समान विचार है । बस दिशा सरणी को अलग तरीके से निपटाया जाता है, क्योंकि AFAIK गोल्फस्क्रिप्ट में एक अरेटी रोटेट फ़ंक्शन नहीं है। इस मामले में, मैं एक पर्याप्त रूप से बड़ी दिशाओं के सरणी का निर्माण करता हूं, इसे 10000 गुना बढ़ाकर और फिर इसकी शुरुआत 0, 1, या 3 तत्वों से ट्रिमिंग करके, वर्तमान कमांड (एस, आर, या एल) पर निर्भर करता है। "स्थानांतरित करने के लिए" वर्तमान दिशा हमेशा सरणी में पहला आइटम है।

यहाँ यह टिप्पणियों के साथ है:

# Build the direction array and set current position
[1 10000:z-1z~)]z*z

@{
  # For each character in the input:

  # set current direction by cutting 0, 1 or 3 elements 
  # from the beginning of the directions array
  'SR L'?
  @>

  # move to current direction
  .0=@+.

  # format as number and addd newline
  `n
}%

# split by newlines
n/

# cleanup
@;\;

# return 1 if array contains distinct elements, 0 otherwise
..&=

संपादित करें:

सहेजे गए 1 char को "दिशाओं" सरणी में कैसे संशोधित किया जाता है।

संपादित करें:

?(पावर) सिंटैक्स का उपयोग करने के लिए 1 के बजाय 10 की वेतन वृद्धि से 1 चार्ट को बचाया ।