আসুন কিছু কর্ম দেখুন!


24

দ্রুত শোরগোলযুক্ত গাড়িগুলির সাথে অ্যাকশন চলচ্চিত্রগুলি কে পছন্দ করে না, বিশেষত যারা প্রচুর ক্র্যাশ করেছেন? অ্যাসি আর্টে অ্যাকশন শট কে পছন্দ করে না?

দৃশ্যটি হ'ল:

দুটি গাড়ি সোজা রাস্তার বিপরীত দিকে শুরু হচ্ছে (এর মধ্যে 60 স্পেস সহ)। তারা অবিচ্ছিন্ন গতিতে একে অপরের দিকে চালনা শুরু করে। গাড়িটি প্রতি সেকেন্ডে 1 স্পেসে বাম চালনা করে এবং এক সেকেন্ডে 2 স্পেসে ডান ড্রাইভ করে।

স্পষ্টতই, গাড়িগুলি একে অপরের মধ্য দিয়ে যেতে পারে না, সুতরাং n ≥ 20দৃশ্যটি দুটি ক্র্যাশযুক্ত গাড়ি হবে যেখানে বোনাট রয়েছে এমন অবস্থানে যেখানে ক্র্যাশ হয়েছিল।

একজন চলচ্চিত্র প্রেমী হিসাবে, আমি কেবল তার সৌন্দর্য উপভোগ করার জন্য এই দৃশ্যের এখনই বিরতি দিতে চাই।

একটি পূর্ণসংখ্যা n(ফাংশন আর্গুমেন্ট বা STDIN) দেওয়া, দৃশ্যটির শুরু থেকে সেকেন্ডের সংখ্যা উপস্থাপন করে, সেই মুহুর্তে দৃশ্যটি প্রদর্শন করুন।

সামনের চাকার মধ্যে space০ টি স্পেস সহ এটিই শুরু করার দৃশ্য:

  __                                                                __
_/  \_                                                            _/  \_
o    o                                                            o    o

এটি 11 সেকেন্ড পরে দৃশ্য:

             __                               __
           _/  \_                           _/  \_
           o    o                           o    o

এবং এটি ক্র্যাশটির পরে দেখতে দেখতে এটির মতো দেখাচ্ছে (নোটগুলি ক্র্যাশের পরে শেষ হয়েছে):

                      __    __
                    _/  \/\/  \_
                    o    oo    o

আমি কেবল দুটি গাড়ি ক্রাশ হওয়ার জন্য আগ্রহী, তাই স্পেস, নিউলাইনগুলি, ++ কিছু যায় আসে না।

এটি কোড গল্ফ, তাই বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী। পরে যুক্ত করা উত্তরগুলি যদি বর্তমান গৃহীত উত্তরের চেয়ে কম হয় তবে তারা জিততে পারে।


2
এটি নিহিত, তবে ক্র্যাশ (20s?) কেবলমাত্র ডাউনটনের / \ বিপরীতে বোনেটগুলি আপ করার পরে _ _?
Sp3000

2
@ স্টেভিগ্রিফিন চমৎকার একটি !!
লুইস মেন্ডো

উত্তর:


10

সিজেম, 68 66 বাইট

liKe<:M"  __  _/  \_o    o"6/f{\S*1$+60M3*-S*@N}:+MK={58'/t59'\t}&

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

যে কেউ কোডটির সূচনা দেখে তা নিশ্চিত হয়ে liKeযাবে!

ব্যাখ্যা:

li      Get input n and convert to integer.
Ke<     Cap n at 20.
:M      Save in variable M for multiple use later.
"  __  _/  \_o    o"
        Car (18 characters).
6/      Split into 3 lines of 6 characters.
f{      Map lines with parameter.
  \       Swap n to top.
  S*      Create string with n spaces for left margin.
  1$      Copy one car line to top. Keep original for second car
  +       Concatenate the spaces and car.
  60M3*-  Calculate 60-3*n, which is the amount of space between cars.
  S*      Create string with 60-3*n spaces.
  N       Add a newline.
}       End of line mapping.
:+      Concatenate all output pieces into single string.
MK=     Check if capped n is equal to 20.
{       If equal, replace hoods with crashed versions.
  58'/t   '/ at position 58.
  59'\t   '\ at position 59.
}&      End of conditional block for crashed hoods.

প্রথম চারটি চরিত্র কি ভোটারদের জন্য একটি পরম বার্তা?
জন ডিভোরাক

@ জনডভোরাক সম্পূর্ণ! :) আচ্ছা, এটি আর পুরোপুরি আঁচল ছিল না কারণ আমি এটিকে নির্দেশ করেছি pointed কোনও আসল উদ্দেশ্য নেই, তবে আমি উত্তরটি কোডটি আটকানোর সাথে সাথে তা অবিলম্বে লক্ষ্য করেছি।
রেটো কোরাডি

14

ল্যাবরেথ , 394 386 বাইট

আমি গর্বের সাথে পরিচয় করিয়ে দিচ্ছি ...

<}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111
?                        @
:" }}_47}_95    3""""""""(
 _ :       }    _   }    {=}
 2 23_}29_ _    ;   :      \
 0       ; 3  +_( 3_"  60{ .{.{.
"-_95:}}"" 2  0 ) 2 "  _ _ {
""       _ :  2 _ ."(; } 3 .{
 ;_92}_47} :  _ 0    = : *  ;
           : "" 2 {.{{ . -""(
}}:59_}}:::: "";_ .    {  _ "
}             "   {.{.{.  32.
}}}_95:}}}}_20-

... আমার নতুন দ্বি-মাত্রিক এলসোং ল্যাবরেথ! উপরের কোডটি অবিশ্বাস্যরকমভাবে গল্ফ হয় না (এখানে ১1১ টি স্পেস এবং 25 এনওপি রয়েছে, সুতরাং আরও ভাল লেআউটটি এটি অনেকটা সংক্ষিপ্ত করতে পারে), তবে কমপক্ষে আমি দেখাতে সক্ষম হয়েছি যে ভাষাটি তুচ্ছ-তুচ্ছ কাজের জন্য ব্যবহারযোগ্য। :)

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

প্রথমত, ভাষার একটি দ্রুত সংক্ষিপ্ত বিবরণ:

  • ল্যাবরেথ দুটি স্ট্যাকের উপর পরিচালিত হয়, প্রধান এবং সহায়ক , যা স্বেচ্ছায় স্বাক্ষরিত পূর্ণসংখ্যার ধারণ করতে পারে। উভয় স্ট্যাকের নীচে রয়েছে অসীম পরিমাণ শূন্য।
  • কমান্ডগুলি 2D গ্রিডের স্বতন্ত্র অক্ষর এবং এগুলি একটি গোলকধাঁধা তৈরি করে (এটি অজানা অক্ষর, বিশেষত স্পেসগুলি দেয়াল হয়)। "হ'ল একটি এনওপি যা কোনও প্রাচীর নয় এবং কোডের কয়েকটি নির্দিষ্ট রাস্তায় প্যাডিংয়ের জন্য সহায়ক হতে পারে। অন্যান্য অনেক 2 ডি ভাষার বিপরীতে, প্রান্তগুলি প্রায় মোড়ানো হয় না
  • নির্দেশ পয়েন্টার (আইপি) প্রথম নন-ওয়াল অক্ষর (পঠন ক্রমে) ডান দিকে সরানো শুরু হয়। @প্রোগ্রামটি সমাপ্ত করে।
  • যদি সম্ভব হয়, আইপি করিডোরগুলি অনুসরণ করে (বাঁকের চারপাশেও)। আইপি-তে সরানোর জন্য যদি একাধিক কোষ থাকে তবে মূল স্ট্যাকের শীর্ষটি নেতিবাচক হলে এটি সাধারণত বাম দিকে ঘুরতে থাকে, শূন্য হলে সোজা এগিয়ে যান, বা এটি ইতিবাচক হলে ডানদিকে ফিরে যান। আইপি যখন দেয়ালে আঘাত করে তখন দিকটি বিপরীত হয়। (আরও কয়েকটি সূক্ষ্মতা রয়েছে, তবে তাদের এই কোডটির পক্ষে কোন গুরুত্ব দেওয়া উচিত নয়)) নিয়ন্ত্রণ প্রবাহ বাস্তবায়নের একমাত্র উপায় এটি।
  • গাণিতিক এবং স্ট্যাক ম্যানিপুলেশন কমান্ডগুলি ছাড়াও উত্স কোডটি রান কালে চারটি কমান্ডের সাহায্যে সংশোধন করা যায় >v<^যা উত্স কোডের একটি সারি বা কলামটি ঘূর্ণায়মানভাবে একটি ঘর দ্বারা স্থানান্তরিত হবে। কোন সারি বা কলামটি প্রভাবিত হয়েছে তা স্ট্যাকের শীর্ষের উপর নির্ভর করে। যদি আইপির নিজস্ব সারি বা কলামটি স্থানান্তরিত হয় তবে এটি শিফ্টের সাথে সরে যাবে। এটি উত্স কোডের এক প্রান্ত থেকে অন্য প্রান্তে ঝাঁপিয়ে পড়া সম্ভব করে।

এখন এই নির্দিষ্ট চ্যালেঞ্জের জন্য, অ্যালগরিদমের সাধারণ ধারণাটি এখানে:

  • / \_o oo oসহায়তার স্ট্যাকের উপরে গাড়িগুলির প্রান্তটি বোতামগুলি (অর্থাত্ ) পর্যন্ত ধাক্কা দিন ।
  • ইনপুটটি পড়ুন এবং ধাক্কা দেওয়ার জন্য __বা /\পরবর্তীটি নির্ধারণ করুন ।
  • সহায়ক বাকী __ __ _/ \স্ট্যাকের উপরের গাড়িগুলি (যেমন এবং দুটি শীর্ষস্থানীয় স্থান) পুশ করুন ।
  • সর্বাধিক মান ইনপুট ক্ল্যাম্প করুন 20, আসুন এই এন কল করুন ।
  • এখন নিম্নলিখিত 3 বার করুন:
    • এন স্পেস প্রিন্ট করুন ।
    • 6 সঞ্চিত অক্ষর মুদ্রণ করুন।
    • 60 - 3 * এন স্পেস মুদ্রণ করুন ।
    • 6 সঞ্চিত অক্ষর মুদ্রণ করুন।
    • একটি নতুন লাইন প্রিন্ট করুন।

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

}74}}:23}29}59}}}}}}}:111_}}}}:::::::23_}:111<

আপনি প্রচুর পরিমাণে রৈখিক কোড দিয়ে শুরু করতে চাইলে এই সারিটি স্থানান্তর গল্ফিংয়ের জন্য কার্যকর।

এরপরে আমরা ইনপুটটি পড়ি এবং সঠিক বোনেটগুলি চাপি:

?  
:" 
 _ 
 2 
 0       ;
"-_95:}}""
""       _
 ;_92}_47}

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

এখন আরও একটি বৃহত রৈখিক বিভাগ অনুসরণ করা হয়েছে (যা সম্ভবত অন্য সারি-শিফটিং ট্রিক দিয়ে প্রচুর গল্ফ করা যেতে পারে):

   }}_47}_95 
   :       } 
   23_}29_ _ 
           3 
           2 
           : 
           : 
           : 
}}:59_}}:::: 
}
}}}_95:}}}}

এটি সহায়ক বাকী স্ট্যাকের উপরের গাড়িগুলিকে ধাক্কা দেয়।

এর পরে, আমরা গণনা করব min(20, input), যা প্রথম শাখার অনুরূপ:

                ;
              +_(
              0 )
              2 _
              _ 0
             "" 2
             "";_
              "  
           _20-

অবশেষে, আমাদের কাছে লুপ রয়েছে যা লাইনগুলি প্রিন্ট করতে তিনবার চলে। লুপের প্রতিটি পুনরাবৃত্তিতে শূন্যস্থানগুলি মুদ্রণের জন্য দুটি ছোট (3x3) লুপ থাকে, পাশাপাশি সহায়ক স্ট্যাক থেকে 6 টি অক্ষর মুদ্রণের জন্য দুটি বিভাগ রয়েছে:

                         @
                3""""""""(
                _   }    {=}
                    :      \
                  3_"  60{ .{.{.
                  2 "  _ _ {
                  ."(; } 3 .{
                     = : *  ;
                  {.{{ . -""(
                  .    {  _ "
                  {.{.{.  32.

একটি নিফটি ট্রিক যার দিকে আমি দৃষ্টি আকর্ষণ করতে চাই তা হ'ল .{.{.ডান প্রান্তে। এটি একটি শেষ প্রান্ত, সুতরাং শেষেটি বাদে .কোডটি দু'বার কার্যকর করা হয়, একবার এগিয়ে এবং একবার পিছনে। এটি প্যালিনড্রমিক কোড সংক্ষিপ্ত করার একটি ঝরঝরে উপায় দেয় (ক্যাচটি হ'ল আপনাকে নিশ্চিত করতে হবে যে পুনরায় মৃতের শেষের সময় প্রস্থান করার সময় আইপি সঠিকভাবে মোড় নিচ্ছে)।


চ্যালেঞ্জ: মনসোপসিত ফন্ট ছাড়াই ল্যাবরেথে একটি প্রোগ্রাম লিখুন ;)
বিটা ডেকে

1
@ বেটাডেকে যে কোনও ভাষায় বেদনাদায়ক মনে হয়। ;)
মার্টিন ইন্ডার

7

পাইথন ২.7, 167 164 159 বাইট

n=input();s,x=60-3*n,min(n,20)
for e in['  _',"_/ ","o  "]:p=e+(e[::-1],(' \_',' \/')[s<1])['/'in e];print" "*x+p+" "*s+(p[-1]+p[1:-1]+p[0]).replace("//","\/")

এটি স্টিডিনের কাছ থেকে ইনপুট নেয়।
ডেমো এখানে এটি
পরীক্ষা করে -

$ ./cars.py
0
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o

$ ./cars.py
11
             __                               __  
           _/  \_                           _/  \_
           o    o                           o    o

$ ./cars.py
20
                      __    __  
                    _/  \/\/  \_
                    o    oo    o

2
(n,20)[n>20]সহজভাবে min(n,20)
অরল্প

@orlp ধন্যবাদ :)
Kamehameha

আপনি প্রতিস্থাপন দ্বারা একটি বাইট সংরক্ষণ করতে পারবেন (' \_',' \/')[s<1]সঙ্গে ' \\\\_/'[s<1::2]
kirbyfan64sos

এছাড়াও, lপ্রয়োজনীয়? আপনি কি কেবল পুরোপুরি করতে for e in [' _',"_/ ","o "]:এবং মুছে ফেলতে পারেন l?
kirbyfan64sos

@ kirbyfan64sos হ্যাঁ, lএখনই প্রয়োজনীয় নয়। আমার এটি আগের সংস্করণে ব্যবহার করতে হয়েছিল। ধন্যবাদ :)
কামেহামেহা

5

আর, 191 বাইট

আমি এখন এটি পেতে পারি হিসাবে প্রায় ভাল। STDIN এবং বিড়াল থেকে STDOUT এ সেকেন্ড নেয়।

n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n<21)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')

ব্যাখ্যা

# Get the input from STDIN.  Requires a single number 0-20
n=scan();
# alias paste0 and set collapse default to ''
p=paste0;
formals(p)$collapse='';
# output
cat(
    # sprintf to format the strings
    sprintf(
        # vector of strings to format                                                      picks which bonnet to remove
        c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n<21)]
        # move left car by 1
        ,p(rep(' ',n))
        # move right car by 2
        ,p(rep(' ',60-n*3))
    )
,sep='\n')

টেস্ট

> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 0
2: 
Read 1 item
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o
> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 5
2: 
Read 1 item
       __                                                 __  
     _/  \_                                             _/  \_
     o    o                                             o    o
> n=scan();p=paste0;formals(p)$collapse='';cat(sprintf(c('%s  __  %s  __  ','%s_/  \\_%s_/  \\_','%s_/  \\/%s\\/  \\_','%so    o%so    o')[-3+(n==20)],p(rep(' ',n)),p(rep(' ',60-n*3))),sep='\n')
1: 20
2: 
Read 1 item
                      __    __  
                    _/  \/\/  \_
                    o    oo    o
> 

চমৎকার কাজ! এবং চতুর ব্যবহার formals()। :)
অ্যালেক্স এ।

@ অ্যালেক্সা এটি কেবল আমার শেষে একজনকে বাঁচিয়েছিল, তবে দুটি ধসে পড়ে যাওয়া কিছুটা আপত্তিজনক ছিল
মিকিটি

আপনার এবং আমার "আক্রমণাত্মক" এর খুব আলাদা সংজ্ঞা রয়েছে।
অ্যালেক্স এ।

4

সিজেম, 120 বাইট

q~20e<_["   "]*\[" _o"]\[" / " "_  " "_  " " \ " ]\[19>" /o"" _o"?]60 3 5$,*-["   "]*[0$," _o"" \o"?]3$[" _o"]+++++++zN*

ডেমো

Ungolfed:

q~        e# Read the input
20e<      e# min(20, input) (let's call it N)
_         e# Duplicate the value on the stack
["   "]   e# Push 3 blank spaces
*         e# Create N arrays of 3 blank spaces
\         e# Swap the top two stack elements
[" _o"]   e# Push the " _o" string to stack
\         e# Swap the top two stack elements
[" / " "_  " "_  " " \ " ]
\         e#
[         e# If N is greater than 20 then push the array [" /o"],
  19      e# otherwise [" _o"]
  >
  " /o"
  " _o"
  ?
]
60        e# 60 is the maximum space between the two cars
3         e# 3 is the number of blocks covered per move
5$,       e# Take the 6th element from the stack (an array of size N)
*-        e# Compute the remaining blocks (60 - 3 * N)
["   "]   e# Add an array of 3 blank spaces
*         e# Multiply it to fit the remaining blocks
[0$," _o"" \o"?] e# Add the (broken?) front part of the second car
3$        e# Copy the middle part of the car
[" _o"]   e# Append the right side of the car
+++++++   e# Concatenate all arrays
z         e# Transpose the array
N*        e# Join the array using new lines

ডেমো


বাম এবং ডান গাড়ীর জন্য পৃথক স্ট্রিং না রেখে আপনি বেশ কিছু কোড সংরক্ষণ করতে সক্ষম হবেন, যেহেতু তারা মূলত একই (ক্র্যাশ কেস বাদে)। স্থানীয় উন্নয়নের একটি দম্পতি: চলকটির Jমান 19 হয়, K20 টির মান থাকে, সেই ধ্রুবকগুলির জন্য প্রতিটি অক্ষর সংরক্ষণ করে। আপনার যদি একটি এলিমেন্টের সাথে অ্যারের প্রয়োজন হয় তবে আপনি aজুড়ি বন্ধনী ব্যবহার না করে উপাদানটি মোড়ানোর জন্য অপারেটরটি ব্যবহার করতে পারেন ।
রেটো কোরাডি

টিপস এবং পোস্ট সিজেএম কোডের জন্য ধন্যবাদ। এটি অন্যান্য অনেক সম্ভাব্য উন্নতি দেখতে আসলে অনেক সাহায্য করে।
রাজওয়ান

4

পিএইচপি, 160 155 বাইট

$f=str_repeat;echo$l=$f(' ',$s=min(max($argv[1],0),20)),"  __  ",
$m=$f(' ',$r=60-3*$s),"  __\n{$l}_/  \\",$r?_.$m._:'/\\',
"/  \\_\n{$l}o    o{$m}o    o\n";

কোড বক্সের লেআউটে ফিট করার জন্য কোডটি এখানে 3 লাইনে প্রদর্শিত হবে। New নতুন লাইনের দরকার নেই।

অবারিত কোড:

// The number of seconds, between (and including) 0 and 20
$sec  = min(max($argv[1], 0), 20);
$rest = 60 - 3 * $sec;

$left = str_repeat(' ', $sec);      // left padding
$mid  = str_repeat(' ', $rest);     // space in the middle
$c = $rest ? '_'.$mid.'_' : '/\\';

echo($left.'  __  '.$mid."  __\n");
echo($left.'_/  \\'. $c ."/  \\_\n");
echo($left.'o    o'.$mid."o    o\n");

এটি কমান্ড লাইন থেকে প্রথম সেকেন্ডের সংখ্যা পায় (প্রথম যুক্তি):

$ php -d error_reporting=0 action.php 11
             __                               __
           _/  \_                           _/  \_
           o    o                           o    o

পিএইচপি সিএলআই বিকল্পটি অপরিশোধিত -d error_reporting=0ধ্রুবকগুলি ( str_repeat, _) সম্পর্কে পিএইচপি প্রদর্শনগুলি লুকিয়ে রাখার জন্য প্রয়োজনীয় যা এটি স্ট্রিংগুলিতে রূপান্তর করে (প্রতিটি নোটিশের জন্য সংরক্ষিত 2 বাইট)।

$fএর প্রথম ব্যবহারের ( $m=($f=str_repeat)(...)) ব্যবহারের সূচনাটি পিষে পিএইচপি 7 এ একটি অতিরিক্ত বাইট সংরক্ষণ করা যায় ; এটি পিএইচপি 5 এ সংকলন করে না।

কোড কেস সঙ্কুচিত করার জন্য পরীক্ষার কেস এবং কিছু কৌশলগুলি পাওয়া যাবে গিথুব থেকে

হালনাগাদ:

@ ইসমাইল- $leftমাইগুয়েল সূচনাটি নিচু $cকরে এবং echo4 টি বাইট সংরক্ষণের যুক্তিগুলিতে ইনলাইন করেছে (নীচে মন্তব্য দেখুন)।

অর্ডারটি ভেরিয়েবলগুলি অদলবদল করে $mএবং sআরম্ভ করা হয় আমি এক জোড়া বন্ধনী থেকে মুক্তি পেয়েছি এবং আরও 1 বাইট সংরক্ষণ করেছি।


156 বাইট:$f=str_repeat;$m=$f(' ',$r=60-3*($s=min(max($argv[1],0),20)));echo$l=$f(' ',$s)," __ $m __\n{$l}_/ \\",$r?_.$m._:'/\\',"/ \\_\n{$l}o o{$m}o o\n";
ইসমাইল মিগুয়েল

@ ইসমাইলমিগুয়েল 155 বাইট:$f=str_repeat;echo$l=$f(' ',$s=min(max($argv[1],0),20))," __ ",$m=$f(' ',$r=60-3*$s)," __\n{$l}_/ \\",$r?_.$m._:'/\\',"/ \\_\n{$l}o o{$m}o o\n";
অ্যাক্সিয়াক

আমি আপনার সন্ধানের বিভিন্নতার চেষ্টা করেছি এবং আমি আসলে দীর্ঘতর কোড পেয়েছি। আপনি নিজের উত্তরটি সম্পাদনা করতে পারেন এবং বাইট গণনা আপডেট করতে পারেন
ইসমাইল মিগুয়েল

আমি o oএকটি চলকতেও বের করার চেষ্টা করেছি কিন্তু একই দৈর্ঘ্য বা এর চেয়েও খারাপ পেয়েছি।
axiac

আপনি \nবাস্তব newlines সঙ্গে প্রতিস্থাপন করতে পারেন । আমি এটি সম্পর্কে ভুলে গেছি। এবং এটি প্রতিটি বাইট হিসাবে প্রতিটি হিসাবে গণনা করা হয়
ইসমাইল মিগুয়েল

3

জাভাস্ক্রিপ্ট (ES6), 121 বাইট

টেমপ্লেট স্ট্রিং ব্যবহার করে, স্ট্রিংয়ের ভিতরে থাকা 2 টি নতুন লাইনগুলি লক্ষণীয় এবং গণনা করা হয়।

বাইটগুলি সঞ্চয় করতে, আউটপুট সহ alert, এমনকি যদি আনুপাতিক ফন্ট ব্যবহৃত হয় তবে alertএটি ASCII আর্টের জন্য উপযুক্ত নয় এবং ফলাফলটি>> n> = 20 (ক্র্যাশ) এর জন্য কুৎসিত।

ফায়ারফক্সে স্নিপেট চালানোর পরীক্ষা করুন

F=n=>alert(`  __  
_/  \\_
o    o`.replace(/.+/g,v=>(Z=x=>' '.repeat(x)+v)(n<20?n:n=20)+Z(60-3*n)).replace('__/','/\\/'))
<input id=I value=10><button onclick='F(I.value)'>go</button>


2

পাইথন 2, 148 বাইট

কার্সারটি সঠিক জায়গায় আঁকতে সঠিক স্থানে এএনএসআই এস্কেপ কোডগুলি ব্যবহার করে। এরপরে এটি ইনপুটটি 20 টি কিনা তা পরীক্ষা করে দেখুন এটি যদি ফিরে আসে তবে এটি পিছনে যায় এবং গাড়ির বোনেটগুলিতে টান দেয়।

স্টিডিন থেকে আউটপুট স্টাডাউটে একটি ইনট নেয়।

p=lambda x:"u  __u_/  \_uo    o".replace("u","\n\033[%dC")%(x,x,x)+"\033[4A";i=min(20,input());print p(i)+"\n"+p(66-i*2)+"\n\n\n\033[25C/\\"*(i==20)

Ungolfed:

def get_car(x):
    return "\n  __\n_/  \_\no    o".replace("\n","\n\033[%dC")%(x,x,x)+"\033[4A"

i=min(20,input())
print get_car(i)
print get_car(66-i*2)
if i==20:
    print"\n\n\033[25C/\\"

2

পাইথ, 67 বাইট

Kjbm+++*\ JhS,Q20d*\ -60*3Jdc3"  __  _/  \_o    o"?nJ20KXXK58\/59\\

এখানে চেষ্টা করে দেখুন ।

                                                                       Implicit: Q=eval(input())
          JhS,Q20                                                      Set J=min(Q,20)
                              "  __  _/  \_o    o"                     Concatenated car string
                            c3                                         Split into 3
   m                                                                   For d in the above
       *\ J                                                            J spaces before 1st car
                  *\ -60*3                                             60-3J spaces in between them
    +++          d         d                                           Concatenate spaces and car string
Kjb                                                                    Join on newlines, store in K
                                                  ?nJ20                If J != 20...
                                                       K               ... print K
                                                         XK58\/        ... else put / in position 58
                                                        X      59\\        and \ in position 59 (implicit print)

2

সি, 180 191 168 বাইট

#define S(x,y)"  __  ",#x"/  \\"#y,"o    o",
char*s[][3]={S(_,_)S(_,/)S(\\,_)};i;l;f(n){l=n>19&&(n=20);for(i=0;i<3;i++)printf("%*s%*s\n",n+6,s[l][i],60-3*n,s[l*2][i]);}

ungolfed:

// make a map of possible car parts
#define S(x, y) { "  __  ", #x "/  \\" #y, "o    o" }
char * s[4][3]= {
    S(_,_),
    S(_,/),
    S(\\,_)
};
i,l;
f(n){
    i = 0;
    l = n>19 && (n = 20); // l = 1, if crash happend
    for(; i < 3; i++) {
        // '*' means length (padding) is given as an int argument
        printf("%*s%*s\n", n + 6, s[l][i], 60 - 3 * n, s[l*2][i]);
    }
}

পরীক্ষা প্রোগ্রাম:

main() {
    f( 0);f( 5);f(10);
    f(15);f(20);f(21);
    return 0;
}

আউটপুট:

  __                                                          __
_/  \_                                                      _/  \_
o    o                                                      o    o
       __                                           __
     _/  \_                                       _/  \_
     o    o                                       o    o
            __                            __
          _/  \_                        _/  \_
          o    o                        o    o
                 __             __
               _/  \_         _/  \_
               o    o         o    o
                      __    __
                    _/  \/\/  \_
                    o    oo    o
                      __    __
                    _/  \/\/  \_
                    o    oo    o

আমি এই একটি খুব কঠিন গল্ফ করতে সক্ষম ছিল। আমি মনে করি আমি প্রায় 300 বাইট দিয়ে শুরু করেছি।

তবে এটি এখনও সমস্ত প্রয়োজনীয়তা পূরণ করে কিনা আমি জানি না। আপনি 21 সেকেন্ডের পরে দেখতে পাচ্ছেন, প্রথম গাড়িটি দ্বিতীয় গাড়িটিকে ডানদিকে ঠেলে দেয়। এটি অনুমোদিত না হলে আমাকে কয়েকটি বাইট যুক্ত করতে হবে।

সম্পাদনা: এটি স্থির। এটি শার্কনাদোর চেয়ে আরও বাস্তবসম্মত হওয়া উচিত ;-)

সম্পাদনা:printf ম্যান-পৃষ্ঠাতে দ্বিতীয়বার দেখে আমি আমার সমাধানটি উল্লেখযোগ্যভাবে ছোট করতে পারি । আপনি যদি '*' ব্যবহার করেন তবে sprintfআগে থেকে ফরম্যাট-স্ট্রিং তৈরি করার প্রয়োজন ছাড়াই আপনি ফিল্ডের দৈর্ঘ্য সরাসরি প্রিন্টফেমে সরবরাহ করতে পারেন ।


দ্রুত গাড়ীটি অন্য গাড়ির ভারীতার জন্য ক্ষতিপূরণ দেয়। এগুলি আঘাত করার পরে চলা উচিত নয়, বা ডানদিকে গতি দ্বিগুণ হওয়ার পরে সম্ভবত বাম দিকে কিছুটা সরানো হবে, তবে সম্ভবত বাম দিকে ওজনের দ্বিগুণ নয়।
mbomb007

3
আমি @ এমবম্ব ২০০7 এর সাথে একমত, তবে, শারকনাদো ৩- এর একটি আইএমডিবি-রেটিং রয়েছে ৪.৫, সুতরাং আপনার উত্তর স্পষ্টতই পদার্থবিজ্ঞানকে অস্বীকার করছে, তবে এটি কিছুটা ইতিবাচক স্বীকৃতি প্রাপ্য হতে পারে =)
স্টিভি গ্রিফিন ২

আমি মনে করি প্রত্যাশিত আচরণটি প্রশ্নটিতে স্পষ্টভাবে সংজ্ঞায়িত করা হয়েছে (জোর দেওয়া হয়েছে): "যে কোনও বৃহত্তর এন এর জন্য দৃশ্যটি ক্র্যাশ হওয়ার জায়গাতেই দুটি ক্র্যাশ গাড়ি হবে "। আমি এটি যেভাবে পড়েছি, ক্র্যাশ হওয়ার পরে তাদের অনির্দিষ্টকালের জন্য একই অবস্থানে থাকা উচিত।
রেটো কোরাডি

2

> <> , 538 276 বাইট

 :3*a6*$-:0)?v~~a2*0c4*1-e2*1+6pa9*2+b7p04.
  v          >04.
 >>1[>:0)  ?v~].
  ^  ^-1o" "<
\$:&94&12." ":oo"_":oo" ":oo
\$:&95&12." ":oo"_":oo" ":ooao
\$:&96&12."_"o"/"o" ":oo"\"o"_"o
\$:&97&12."_"o"/"o" ":oo"\"o"_"oao
\$:&98&12."o"o" ":::oooo"o"o
\$:&99&12."o"o" ":::oooo"o"o;

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

আপনি এটি এখানে পরীক্ষা করতে পারেন । "ইনপুট" নয়, "প্রাথমিক স্ট্যাক" তে সময় কাটাতে হবে!

এখানে পুরানো সংস্করণ।

:3*a6*$-:0)  ?v~~a2*0c4*1-c3*1-4p^                        
v~v?)0:  <[1:$/$:1[ >:0)  ?v~]" ":oo"_":oo" ":ooaov       
] >" "o1-^    ^    <^-1o" "/"/"o"_"<]~v?)0:  <[1:$<       
>" ":oo"_":oo" ":oo^       \o" ":oo"\"\" "o1-^            
/o"\"oo:" "o"/"o"_"]~v?)0:  <[1:$o"_"o/                   
\"_"oaov   hi there  >" "o1-^                             
       >$:1[ >:0)  ?v~]"o"o" ":::oooo"o"o>$:1[ >:0)  ?v~]v
       ^    <^-1o" "<                    ^    <^-1o" "<   
              v      p4-1*29+2*9a<    ;o"o"oooo:::" "o"o"<

2

জাভা, 258 চারস

class M{public static void main(String[]a){String l="",m=l,r="  __  ",w="o    o",x="_/  \\_";int p=Integer.parseInt(a[0]),i=20;p=p>i?i:p;for(i=-1;++i<p;)l+=" ";for(;++i<21;)m+="   ";System.out.print(l+r+m+r+"\n"+l+(x+m+x).replace("__","/\\")+"\n"+l+w+m+w);}}

আন Golfed

  class M {
     public static void main(String[] a) {
        String l = "", m = l, r = "  __  ", w = "o    o", x = "_/  \\_";
        int p = Integer.parseInt(a[0]), i = 20;
        p = p > i ? i : p;
        for (i = -1; ++i < p;)
           l += " ";
        for (; ++i < 21;)
           m += "   ";
        System.out.print(l + r + m + r + "\n"
              + l + (x + m + x).replace("__", "/\\") + "\n"
              + l + w + m + w);
     }
  }

ফলাফল

0
  __                                                                __  
_/  \_                                                            _/  \_
o    o                                                            o    o

1
   __                                                             __  
 _/  \_                                                         _/  \_
 o    o                                                         o    o

...

19
                     __       __  
                   _/  \_   _/  \_
                   o    o   o    o

20
                      __    __  
                    _/  \/\/  \_
                    o    oo    o

21
                      __    __  
                    _/  \/\/  \_
                    o    oo    o      

2

পাইথন 2, 102 বাইট

n=input()
for r in"  __  ","_/  \_","o    o":print((n*' ')[:20]+r+(60-3*n)*' '+r).replace('__/','/\/')

অনেকটাই অকপট. গাড়ির প্রতিটি সারির জন্য, আমরা nফাঁকা স্থানগুলি, সেই সারিটি, 60-3*nস্পেসগুলি এবং আবার সারিটি প্রিন্ট করি । গাড়িগুলি থামানোর পরিবর্তে, থামানোর চেয়ে min(n,20)প্রথম স্পেসের সাথে সীমাবদ্ধ করা এটির চেয়ে কম ছিল [:20]এবং দ্বিতীয়টি ভাল কারণ কারণ একটি স্ট্রিংয়ের খালি স্ট্রিং aণাত্মক বার times

ফেন্ডারগুলি সরিয়ে নিতে, আমরা কেবল একটি করি replace। যেহেতু __ছাদেও উপস্থিত রয়েছে, তাই ফেন্ডারদের সনাক্ত করতে আমাদের কিছুটা প্রসঙ্গের প্রয়োজন, তাই আমরা /নীচের জন্য যাচাই করি ।


1

জাভা, 270 267 বাইট

খুব নিশ্চিত যে এটি করার আরও ভাল / খাটো উপায় আছে তবে আমার মস্তিষ্ক সঠিকভাবে নিযুক্ত নেই।

class C{public static void main(String[]a){String l="",m="",r="  __  ",w="o    o";int p=Math.min(Integer.parseInt(a[0]),20),i;for(i=0;++i<p;)l+=" ";for(i=0;++i<60-3*p;)m+=" ";System.out.print(l+r+m+r+"\n"+l+"_/  \\"+(p==20?"/"+m+"\\":"_"+m+"_")+"/  \\_\n"+l+w+m+w);}}

এন = 19 এর জন্য:

                    __      __  
                  _/  \_  _/  \_
                  o    o  o    o

এন = 20 এর জন্য:

                     __    __  
                   _/  \/\/  \_
                   o    oo    o

Ungolfed

public class Crash { public static void main(String[] args) { String left="", mid="", r=" __ ", w="o o"; int pos = Math.min(Integer.parseInt(args[0]),20),i; for (i=0; ++i<pos;){ left+=" "; } for (i=0; ++i<60-3*pos;){ mid+=" "; } System.out.print( left + r + mid + r + "\n" + left + "_/ \\" + (pos==20 ? "/" + mid + "\\" : "_" + mid + "_") + "/ \\_\n" + left + w + mid + w); } }

1
এর ফলাফলগুলি কিছুটা ভুল। আপনার গাড়িগুলি কেবল 59 টি চর আলাদা করে শুরু করে। আমার সমাধান এটিকে ঠিক করে দেয় এবং গল্ফগুলি আপনাকে আরও শক্ত করে :)
ন্যূনতম

ভাল ধরা ও ভাল কাজ করা হয়েছে :)
ডেনহাম কোট

1

পিএইচপি 7, 140 বাইট

<?$s=$argv[1];$r=($f=str_repeat)(~ß,60-3*$s);echo$l=$f(~ß,min(20,$s)),"  __  $r  __  
${l}_/  \\",$r?_.$r._:~У,"/  \_
$l",$o=~ßßßß,$r,$o;

ব্যবহার:

এএনএসআই হিসাবে সংরক্ষণ করুন file.php(এতে শূন্য-প্রস্থের অক্ষর থাকা উচিত $o) এবং চালান:

php -derror_reporting=~E_NOTICE -dshort_open_tag=1 file.php x

সঙ্গে xসেকেন্ডের সংখ্যা হিসাবে।

এবং একটি সংস্করণ যা ত্রুটি প্রতিবেদন ( 148 বাইট ) পরিবর্তন না করে কাজ করে :

<?$s=$argv[1];$r=($f=@str_repeat)(' ',60-3*$s);echo$l=$f(' ',min(20,$s)),"  __  $r  __  
${l}_/  \\",$r?"_${r}_":"/\\","/  \_
$l",$o="o    o",$r,$o;

1

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

এটি বিজয়ী নয়, তবে এটি কিছু

http://jsfiddle.net/yb703y0p/2/

function f(n){
c = ["  __  A", "_/  \\_A", "o    oA"]
for(i=0;i<3;i++)c[i]=c[i].replace('A',' '.repeat(n))+c[i].replace('A','')
if(n==0)c[1]=c[1].replace('__','/\\')
console.log(c.join("\n"))
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.