मिस्र के पिरामिड

Question

मिस्र के सबसे बड़े पिरामिड गीज़ा के महान पिरामिड, न केवल प्राचीन दुनिया के सात अजूबों में से सबसे पुराने हैं, बल्कि यह बड़े पैमाने पर बरकरार रहने के लिए एकमात्र भी है। मिस्र के पिरामिडों को बनने में 20 साल तक का समय लग सकता है और ये इतने बड़े हैं कि क्रूसेडरों को कुचलने वाले महान सलादीन के बेटे अल-अजीज उथमान को गीजा के महान पिरामिडों को ध्वस्त करना छोड़ना पड़ा क्योंकि इसे बहुत बड़ा काम समझा जाता था । मिस्र के पिरामिड ज्यादातर पुराने और मध्य काल (सी। 2686–1690 ईसा पूर्व) के दौरान देश के फिरौन और उनके कन्सर्ट के लिए कब्रों के रूप में बनाए गए थे, और 2008 तक, 138 मिस्र के पिरामिडों की खोज की जा चुकी है।

कार्य एक प्रोग्राम बनाना है जो एक अंतरिक्ष द्वारा अलग की गई दूरी के अनुक्रम का इनपुट करता है, और उन दूरियों द्वारा अलग किए गए 10 × 10 पाठ पिरामिड का उत्पादन करता है। 1 की दूरी दो वर्णों के बराबर है।

एक पाठ पिरामिड इस तरह दिखेगा:

         /\
        /--\
       /----\
      /------\
     /--------\
    /----------\
   /------------\
  /--------------\
 /----------------\
/------------------\

यदि इनपुट में केवल एक पंक्ति विराम होता है, तो ऊपर की तरह एक पिरामिड का उत्पादन किया जाएगा । प्रत्येक पिरामिड के लिए, बाईं ओर के पिरामिड को प्रदर्शित किया जाता है जैसे कि वे सामने थे।

उदाहरण I

इनपुट:

4 3 1

आउटपुट:

         /\      /\    /\/\
        /--\    /--\  /--\-\
       /----\  /----\/----\-\
      /------\/------\-----\-\
     /--------\-------\-----\-\
    /----------\-------\-----\-\
   /------------\-------\-----\-\
  /--------------\-------\-----\-\
 /----------------\-------\-----\-\
/------------------\-------\-----\-\

उदाहरण II

इनपुट:

0 9

आउटपुट:

         /\                /\
        /--\              /--\
       /----\            /----\
      /------\          /------\
     /--------\        /--------\
    /----------\      /----------\
   /------------\    /------------\
  /--------------\  /--------------\
 /----------------\/----------------\
/------------------\-----------------\

उदाहरण III

इनपुट:

11

आउटपुट:

         /\                    /\
        /--\                  /--\
       /----\                /----\
      /------\              /------\
     /--------\            /--------\
    /----------\          /----------\
   /------------\        /------------\
  /--------------\      /--------------\
 /----------------\    /----------------\
/------------------\  /------------------\

वर्णों की सबसे कम मात्रा में इन आवश्यकताओं को पूरा करने के लिए आवेदन विजेता है।

संदर्भ: Wikipedia.org

Comments

मुझे लगता है कि लाइन के अंत में अतिरिक्त व्हाट्सएप की अनुमति है?

— पीटर टेलर

निर्भर करता है कि आप किससे पूछते हैं। युक्ति के सबसे सख्त पढ़ने में, आउटपुट के बाद कोई व्हाट्सएप नहीं है। लेकिन यह देखते हुए कि यह मनोरंजन के लिए है, मुझे इससे कोई समस्या नहीं है।

— नाहरन

तो इनपुट लेने के लिए कमांड लाइन तर्क की अनुमति है?

— जॉय

जब तक यह आवश्यकताओं को पूरा करता है। मैं अब देखता हूं कि व्हिटलेज का समाधान वास्तव में इनपुट के रूप में लाइनब्रेक को संभालने में सक्षम नहीं है (मैं अपने अपवित्र को पूर्ववत् नहीं कर सकता), यह बस इनपुट नहीं होने पर पिरामिड का निर्माण करके इसके चारों ओर काम करता है। लेकिन अगर आप एक समाधान पा सकते हैं जो कमांड लाइन आर्ग्स के रूप में लाइनब्रेक इनपुट (\ r या \ n ठीक है) को संभाल सकता है, तो मेरे साथ ठीक है।

— निरेन

Answer 1

गोल्फस्क्रिप्ट, 70 अक्षर

~]0-:|;10,{:§9\-" "*"/""-"§2**+"\\"+:&|{.§>{§-(2*" "*1$}{-2*&>}if}%n}%

मेरे रूबी समाधान का प्रत्यक्ष बंदरगाह , इसलिए मुझे यकीन है कि यह काफी कुछ पात्रों को छोटा करना संभव है।

Answer 2

विंडोज पॉवरशेल, 122 132 133 139

$d=@(-split$input)-gt0
0..9|%{' '*(9-($x=$_))+($a="/$('--'*$_)\")+-join($d|%{'  '*(($_-$x-1)*($x-lt$_))
$a[(-2*$_)..-1]})}

टेस्ट स्क्रिप्ट ।

यादृच्छिक इनपुट भी अच्छी छवियों के लिए बनाता है:

Comments

अगर मैं $input=Read-Hostशीर्ष पर जोड़ता हूं तो यह काम करता है , अन्यथा यह इनपुट के लिए नहीं कहता है। इसे कैसे चलाना चाहिए?

— नहारें

@ नहरें: echo 0 3 4 1|powershell -noprofile -file pyramids.ps1या पॉवरशेल से '0 1 4 3' | .\pyramids.ps1। आप केवल स्वीकार कर सकते हैं के रूप में यह, PowerShell में गोल्फ, उदासी के साथ एक लगातार समस्या है या तो पहुंचाया-इन इनपुट या इंटरैक्टिव इनपुट। PowerShell में वास्तव में अन्य भाषाओं और परिवेशों की धारणा नहीं है और यह कभी-कभी दिखाता है। मैं आमतौर पर पाइप्ड इनपुट के लिए जाता हूं, जब तक कि कार्य अन्तरक्रियाशीलता के लिए स्पष्ट रूप से कॉल नहीं करता है, जैसे कि संख्या का अनुमान लगाते हैं ।

— जॉय

आह हाँ, अब यह काम करता है। मेरा बटन मैशिंग कोई परिणाम नहीं दे रहा था, और मैं यह पता नहीं लगा सका कि क्यों।

— नहारें

Answer 3

हास्केल, 148 अक्षर

r=replicate
p d=map(\k->foldr(\n i->r(9-k)' '++'/':r(2*k)'-'++"\\"++drop(11+k)(r(2*n)' '++i))""$d++[0])[0..9]
main=interact$unlines.p.map read.words

मैं इससे काफी असंतुष्ट हूं! यह अभी बहुत लंबा रास्ता तय करता है। विचार?

Comments

लैम्ब्डा के अंदर, आप ++एक ही सूची के बड़े ढेर को बदल सकते हैं और कॉकटैट उर्फ ​​का उपयोग कर सकते हैं >>=id। मुझे नहीं पता कि इससे मदद मिलेगी या नहीं। foldr1इसके बजाय एक और बिंदु का उपयोग किया जाएगा foldr।

— 13 दिसंबर को फ़ूजएक्सएक्सएल

विचारों के लिए धन्यवाद। न तो इस मामले में मदद करता है: ++दृश्यों को परिवर्तित करने से आपको प्रति आइटम केवल एक चरित्र की बचत होती है, और concatयहां अंतिम ओवरहेड बहुत अधिक है। foldrउपयोग कर सकते हैं नहीं foldr1के रूप में परिणाम समय है प्रपत्र Stringजबकि सूची प्रकार है [Int]( 1वेरिएंट foldकी आवश्यकता होती है उन्हें एक ही हो सकता है।)

— MtnViewMark

Answer 4

अजगर, 123 वर्ण

N=[10]+map(int,raw_input().split())
for y in range(10):print''.join((2*n*' '+'/'+2*y*'-'+'\ ')[-2*n-1:-1]for n in N)[9-y:]

Comments

जिज्ञासा से बाहर, क्या यह अजगर 2.5 है? पायथन 3.2 में काम करने के लिए इसे पाने के लिए, मैंने मैप फ़ंक्शन को एक लिस्ट फ़ंक्शन में लपेट दिया, कच्चे_input () से इनपुट () में बदल दिया, और प्रिंट से प्रिंट में बदल दिया ()।

— नहरें

@ नाहरन: मेरे लिए 2.4.4 और 2.5.2 दोनों में काम करता है।

— कीथ रान्डेल

Answer 5

रूबी 1.9, 116 वर्ण

d=gets.split-[?0]
10.times{|i|puts [?\s*(9-i),l=?/+?-*2*i+?\\,d.map{|r|i<(r=r.to_i)??\s*2*(r+~i)+l :l[-2*r,99]}]*""}

Answer 6

पर्ल, 130 126 132 चार

$_=<>;$s=" "x9;map{$k.="/\\"."  "x($_-1)if$_}split;$_="$s$k/\\$s\n";for$i(0..9){print;s%\\-%-\\%g;s%\\/%-\\%g;s%\\ %-\\%g;s% /%/-%g}

थोड़ा छोटा संस्करण जो स्टड से बजाय कमांड-लाइन तर्कों के रूप में इनपुट लेता है:

$s=" "x9;map{$k.="/\\"."  "x($_-1)if$_}@ARGV;$_="$s$k/\\$s\n";for$i(0..9){print;s%\\-%-\\%g;s%\\/%-\\%g;s%\\ %-\\%g;s% /%/-%g}

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

(साभार, @mbx, 4 वर्णों के लिए)।

Comments

foreach == के लिए -> 4 वर्णों को बचाएं

— mbx

क्या आपने दिए गए टेस्टकेस के साथ अपने संस्करण का परीक्षण किया है ?!

— mbx

@mbx, हाँ, मेरे लिए काम करता है। पर्ल 5.10.1, उबंटू। क्या बग देख रहे हो?

— पीटर टेलर

@Peter टेलर - मेरे ubuntu और win32 पर यह भी ठीक काम करता है। मैंने पहली बार इसे आइडोन पर आज़माया था, जो प्रति 5.1.1.1 पर चल रहा है।

— mbx

»अगर इनपुट में केवल एक लाइन ब्रेक होता है« मानक इनपुट पर संकेत, वास्तव में।

— जोए

Answer 7

जावास्क्रिप्ट, 396 बाइट्स

function p(a){for(u=0;u<10;u++){t[u+a][9-u]="/";for(k=9-u+1+a;k<10+u+a;k++)t[k][u]="-";
t[10+u+a][u]="\\"}}function _(a){t=[];for(i=0;i<50;i++){t[i]=[];for(j=0;j<10;j++)t[i][j]=" "
}var a=a.split(" "),b=a.reduce(function(a,b){return a-0+(b-0)})*2;for(i=a.length-1;i>=0;
i--)p(b),b-=a[i]*2-0;p(0);a="";for(j=0;j<10;j++){b="";for(i=0;i<50;i++)b+=t[i][j];
a+=b.replace(/\s+$/,"")+(j<9?"\n":"")}return a}

मैं जावास्क्रिप्ट के साथ जीतने नहीं जा रहा हूँ, लेकिन अभी जावास्क्रिप्ट प्रविष्टि है :)

उपयोग: _("1 2 3")आदि

Answer 8

रूबी (112)

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

s=' '*9+r='/\\';gets.split.map{|i|s+=' '*2*(i.to_i-1)+r}
10.times{puts s;s.gsub!' /','/-';s.gsub!(/\\.?/,'-\\')}

Answer 9

पॉवरशेल, 105 98 बाइट्स, युक्ति का सबसे सख्त पढ़ना

-7 बटर मिगमारू के उत्तर से ।

($a=' '+-join(,5+$args-gt0|%{'  '*--$_+'/\'}))
1..9|%{($a=$a-replace' /','/-'-replace'\\.?','-\')}

टेस्ट स्क्रिप्ट:

$f = {

($a=' '+-join(,5+$args-gt0|%{'  '*--$_+'/\'}))
1..9|%{($a=$a-replace' /','/-'-replace'\\.?','-\')}

}

@(
,(@"
         /\
        /--\
       /----\
      /------\
     /--------\
    /----------\
   /------------\
  /--------------\
 /----------------\
/------------------\
"@)

,(@"
         /\      /\    /\/\
        /--\    /--\  /--\-\
       /----\  /----\/----\-\
      /------\/------\-----\-\
     /--------\-------\-----\-\
    /----------\-------\-----\-\
   /------------\-------\-----\-\
  /--------------\-------\-----\-\
 /----------------\-------\-----\-\
/------------------\-------\-----\-\
"@, 4,3,1)

,(@"
         /\                /\
        /--\              /--\
       /----\            /----\
      /------\          /------\
     /--------\        /--------\
    /----------\      /----------\
   /------------\    /------------\
  /--------------\  /--------------\
 /----------------\/----------------\
/------------------\-----------------\
"@, 0,9)

,(@"
         /\                    /\
        /--\                  /--\
       /----\                /----\
      /------\              /------\
     /--------\            /--------\
    /----------\          /----------\
   /------------\        /------------\
  /--------------\      /--------------\
 /----------------\    /----------------\
/------------------\  /------------------\
"@, 11)
) | % {
    $expected, $a = $_
    $result = &$f @a
    ($result-join"`n")-eq$expected
    $result 
}

आउटपुट:

True
         /\
        /--\
       /----\
      /------\
     /--------\
    /----------\
   /------------\
  /--------------\
 /----------------\
/------------------\
True
         /\      /\    /\/\
        /--\    /--\  /--\-\
       /----\  /----\/----\-\
      /------\/------\-----\-\
     /--------\-------\-----\-\
    /----------\-------\-----\-\
   /------------\-------\-----\-\
  /--------------\-------\-----\-\
 /----------------\-------\-----\-\
/------------------\-------\-----\-\
True
         /\                /\
        /--\              /--\
       /----\            /----\
      /------\          /------\
     /--------\        /--------\
    /----------\      /----------\
   /------------\    /------------\
  /--------------\  /--------------\
 /----------------\/----------------\
/------------------\-----------------\
True
         /\                    /\
        /--\                  /--\
       /----\                /----\
      /------\              /------\
     /--------\            /--------\
    /----------\          /----------\
   /------------\        /------------\
  /--------------\      /--------------\
 /----------------\    /----------------\
/------------------\  /------------------\

Powershell, 101 94, एक प्रमुख व्हाट्सएप के साथ मज़ा

($a=-join(,6+$args-gt0|%{'  '*--$_+'/\'}))
1..9|%{($a=$a-replace' /','/-'-replace'\\.?','-\')}

Answer 10

मुझे इससे छोटा कोई C # 3 संस्करण नहीं मिला। मुझे नहीं पता कि चरित्र की गिनती ठीक है, लेकिन मुझे संदेह है कि मैं हार गया हूं। :-(

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;

namespace PyramidRenderer
{
    /// <summary>
    /// Generates ASCII-art pyramids at user-specified horizontal locations to
    /// the standard output stream.
    /// </summary>
    public class Program
    {
        /// <summary>
        /// Generates one or more ASCII-art pyramids at the locations specified and 
        /// sends them to the standard output stream.
        /// </summary>
        /// <param name="args">The command-line arguments. These should be non-negative 
        /// integers that specify the horizontal distance of each additional pyramid from the 
        /// preceeding pyramid. Whether or not any distances are suppplied, a pyramid
        /// is rendered at the starting location.</param>
        public static void Main(string[] args)
        {
            try
            {
                AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);

                int[] pyramidDistances = ParsePyramidLocationsFromCommandLine(args).ToArray();
                PyramidCollection pyramids = new PyramidCollection(pyramidDistances);
                pyramids.RenderToText(Console.Out);
            }
            catch (ArgumentException ex)
            {
                Console.Error.WriteLine(ex.Message);
            }
        }

        /// <summary>
        /// Handler for the unhandled exception. This just displays the error message to 
        /// the standard error stream.
        /// </summary>
        /// <param name="sender">Required but unnecessary sender object for the event handler.</param>
        /// <param name="e">The object that represents the exception.</param>
        private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            Debug.Assert(e.ExceptionObject != null);

            string exceptionText;
            Exception ex = e.ExceptionObject as Exception;
            if (ex == null)
                exceptionText = e.ExceptionObject.ToString();
            else
                exceptionText = ex.Message;
            Console.Error.WriteLine(exceptionText);
        }

        /// <summary>
        /// Takes the command-line arguments and converts them to a sequence of 
        /// non-negative integers.
        /// </summary>
        /// <param name="args">The command-line arguments as supplied to Main.</param>
        /// <returns>A sequence of integers that represent the user’s distance selections.</returns>
        /// <exception cref="ArgumentException">An invalid argument was supplied.</exception>
        private static IEnumerable<int> ParsePyramidLocationsFromCommandLine(string[] args)
        {
            Debug.Assert(args != null);

            foreach (string arg in args)
            {
                int result;
                if (int.TryParse(arg, out result))
                {
                    if (result < 0)
                        throw new ArgumentException(string.Format("Invalid distance specified: {0}", arg));

                    yield return result;
                }
                else
                {
                    throw new ArgumentException(string.Format("Invalid option: {0}", arg));
                }
            }
        }
    }

    /// <summary>
    /// Represents a single pyramid to be rendered.
    /// </summary>
    internal class Pyramid
    {
        /// <summary>
        /// The height of the pyramids in text rows. The width of each pyramid will be
        /// twice the height.
        /// </summary>
        internal const int Height = 10;

        /// <summary>
        /// The length in characters of the horizontal unit distance in which the user 
        /// specifies the pyramid distances.
        /// </summary>
        internal const int PyramidUnits = 2;

        /// <summary>
        /// The character to output as the background of the pyramids.
        /// </summary>
        private const char backgroundChar = ' ';

        /// <summary>
        /// The character to output as the left edge of the pyramids.
        /// </summary>
        private const char leftEdgeChar = '/';

        /// <summary>
        /// The character to output within each pyramid, between the edges.
        /// </summary>
        private const char brickChar = '-';

        /// <summary>
        /// The character to output as the right edge of the pyramids.
        /// </summary>
        private const char rightEdgeChar = '\\';

        /// <summary>
        /// The absolute horizonal location of the pyramid’s bottom left corner as 
        /// specified in PyramidUnits.
        /// </summary>
        private int position;

        /// <summary>
        /// Constructs a new pyramid object at the specified location.
        /// </summary>
        /// <param name="position">The absolute horizonal location of the pyramid’s bottom
        /// left corner in PyramidUnits.</param>
        internal Pyramid(int position)
        {
            Debug.Assert(position >= 0);

            this.position = position;
        }

        /// <summary>
        /// Renders a single row the pyramid to the supplied text stream starting at
        /// the indicated location.
        /// </summary>
        /// <param name="textWriter">The output stream to which the pyramid is to
        /// be rendered.</param>
        /// <param name="row">The row of the pyramid to render. Zero is the top row,
        /// and Height - 1 is the bottom row.</param>
        /// <param name="startingPosition">The text character position—indexed at zero—at 
        /// which the rendering is to begin. If non-zero, this identifies the column one 
        /// past the ending location of the previous pyramid.</param>
        /// <returns>The horizontal location (in characters) at which the next item 
        /// may be rendered.</returns>
        internal int RenderRow(TextWriter textWriter, int row, int startingPosition)
        {
            Debug.Assert(textWriter != null);
            Debug.Assert(row >= 0);
            Debug.Assert(startingPosition >= 0);

            int leftBoundary = Height - 1 - row + position * PyramidUnits;
            int rightBoundary = Height + row + position * PyramidUnits;

            startingPosition = RenderField(textWriter, backgroundChar, startingPosition, leftBoundary);
            startingPosition = RenderField(textWriter, leftEdgeChar, startingPosition, leftBoundary + 1);
            startingPosition = RenderField(textWriter, brickChar, startingPosition, rightBoundary);
            startingPosition = RenderField(textWriter, rightEdgeChar, startingPosition, rightBoundary + 1);
            return startingPosition;
        }

        /// <summary>
        /// Outputs a sequence of repeated characters from the indicated starting position to
        /// just before the ending position, unless the starting position is already equal to
        /// or greater than the ending position.
        /// </summary>
        /// <param name="textWriter">The output stream to which the field is to be rendered.</param>
        /// <param name="character">The character to be repeated in the output.</param>
        /// <param name="startingPosition">The location at which rendering may begin in 
        /// characters indexed at zero.</param>
        /// <param name="endingPosition">The location one past the location at which rendering
        /// is to end.</param>
        /// <returns>The position at which the next field may begin.</returns>
        private static int RenderField(TextWriter textWriter, char character, int startingPosition, int endingPosition)
        {
            Debug.Assert(textWriter != null);
            Debug.Assert(startingPosition >= 0);
            Debug.Assert(endingPosition >= 0);

            int charCount = endingPosition - startingPosition;
            if (charCount <= 0)
                return startingPosition;
            textWriter.Write(new string(character, charCount));
            return endingPosition;
        }
    }

    /// <summary>
    /// A collection of pyramids to be displayed.
    /// </summary>
    internal class PyramidCollection
    {
        /// <summary>
        /// A left-to-right ordered list of the pyramids that the user has 
        /// requested to be rendered.
        /// </summary>
        List<Pyramid> allPyramids = new List<Pyramid>();

        /// <summary>
        /// Constructs a new pyramid collection.
        /// </summary>
        /// <param name="distances">The distances of each non-leftmost pyramid (in PyramidUnits) after
        /// the previous pyramid. The total number of pyramids will be one greater than the length of
        /// the distances array.</param>
        internal PyramidCollection(int[] distances)
        {
            Debug.Assert(distances != null);

            int nextPosition = 0;
            allPyramids.Add(new Pyramid(nextPosition));
            foreach (int nextDistance in distances)
            {
                Debug.Assert(nextDistance >= 0);

                try
                {
                    checked
                    {
                        nextPosition += nextDistance;
                        int endLocation = nextPosition * Pyramid.PyramidUnits + Pyramid.Height * 2;
                    }
                }
                catch (OverflowException)
                {
                    // Ignore any pyramids specified beyond the integer maximum distance.
                    break;
                }
                allPyramids.Add(new Pyramid(nextPosition));
            }
        }

        /// <summary>
        /// Outputs ASCII-art images of the pyramids in this collection to the 
        /// provided output stream.
        /// </summary>
        /// <param name="textWriter">The output stream to which the pyramids
        /// are to be rendered.</param>
        internal void RenderToText(TextWriter textWriter)
        {
            Debug.Assert(textWriter != null);

            for (int row = 0; row < Pyramid.Height; row++)
            {
                int startingPosition = 0;
                foreach (Pyramid pyramid in allPyramids)
                {
                    startingPosition = pyramid.RenderRow(textWriter, row, startingPosition);
                }
                textWriter.WriteLine();
            }
        }
    }

}

Comments

क्या आपने किसी भी संयोग से कोड बॉलिंग और कोड गोल्फ को भ्रमित किया?

— जॉय

कम से कम प्रयास करने का दिखावा करें। यदि आप इसे गोल्फ करते हैं तो लोग आपके खिलाफ एक मौखिक भाषा नहीं रखेंगे ।

— dmckee --- पूर्व-मध्यस्थ ने

मुझे लगता है कि आपकी निफ्टी चाल को समझाने के लिए आपका वर्बोज़ संस्करण है। ऐसा लगता है कि आप इसके गोल्फ संस्करण को पोस्ट करना भूल गए हैं।

— mbx

@Joey, @dmckee - मैंने एक गोल्फ संस्करण करने के बारे में सोचा था, लेकिन इसके आसपास नहीं मिला। मैं वैसे भी इस खेल में भयानक हूं। अस्पष्ट कोड पूरी तरह से मेरी प्रकृति के खिलाफ जाता है। मुझे शायद गोल्फ पहेली से दूर रहना चाहिए! - @mbx - अफसोस की बात है कि निफ्टी ट्रिक्स नहीं हैं।

— जेफरी एल व्हिटलेज