27

एक सूची या सीमांकित स्ट्रिंग को देखते हुए, प्रत्येक शब्द एक शब्द के पहले चरित्र के साथ एक सूची या सीमांकित स्ट्रिंग का उत्पादन करें।

इस चुनौती के लिए, एक "शब्द" में केवल सभी मुद्रण योग्य ASCII वर्ण होते हैं, जो अंतरिक्ष, न्यूलाइन और टैब वर्ण को छोड़कर।

उदाहरण के लिए, स्ट्रिंग "गुड दोपहर, वर्ल्ड!" (अंतरिक्ष-प्रतिबंधित):

1. String
"Good afternoon, World!"

2. Get the first characters:
"[G]ood [a]fternoon, [W]orld!"

3. Move the characters over. The character at the end gets moved to the beginning.
"[W]ood [G]fternoon, [a]orld!"

4. Final string
"Wood Gfternoon, aorld!"

यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है!

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

Input -> output (space-delimited)

"Good afternoon, World!" -> "Wood Gfternoon, aorld!"
"This is a long sentence." -> "shis Ts i aong lentence."
"Programming Puzzles and Code Golf" -> Grogramming Puzzles Pnd aode Colf"
"Input -> output" -> "onput I> -utput"
"The quick brown fox jumped over the lazy dog." -> "dhe Tuick qrown box fumped jver ohe tazy log."
"good green grass grows." -> "good green grass grows."

code-golf string

— कॉमरेड स्पार्कलपनी
स्रोत

क्या आउटपुट में अनुगामी स्थान की अनुमति है?

— बिजनेस कैट

क्या हम मान सकते हैं कि शब्दों के बीच सबसे अधिक जगह होगी?

— गणित नशेड़ी

कुछ नियम हैं, जिस पर एक दूसरे को पत्र पालन कर सकते हैं के साथ, आप एक spoonerism जनरेटर होगा en.wikipedia.org/wiki/Spoonerism

— प्रदर्शन नाम

@BusinessCat हां।

— कॉमरेड स्पार्कलपनी

@ मैथजंकी हाँ।

— कॉमरेड स्पार्कलपनी

10

05AB1E , 7 6 बाइट्स

€ćÁ2ôJ

स्पष्टीकरण:

€ć      Extract head of each
  Á     Rotate to the right
    2ô  Split into pieces of length two
      J Join

इसे ऑनलाइन आज़माएं!

— Okx
स्रोत

आप एक सूची के रूप में इनपुट और आउटपुट ले सकते हैं, आप जानते हैं।

— कॉमरेड स्पार्कलपनी

8

जाप , ११ १० ९ by बाइट्स

जाप के इंडेक्स रैपिंग और नेगेटिव इंडेक्सिंग का फायदा उठाता है।

ËhUgEÉ g

इसे ऑनलाइन आज़माएं

व्याख्या

        :Implicit input of array U (each element is an individual word).
Ë       :Map over the array.
h       :Replace the first character of the current element (word) ...
Ug      :  with the word in the array at index ...
EÉ      :    current index (E) -1's ...
g       :  first character.
        :Implicit output of array of modified words

— झबरा
स्रोत

मुझे लगता है कि आप एक सूची के रूप में इनपुट भी ले सकते हैं, एक और बाइट को ¸

— बचाते

यह एक खिंचाव हो सकता है, @ETHproductions, लेकिन मैं पूछूंगा। संपादित करें: यहाँ

— झबरा

1

हां, पोस्ट की शुरुआत में यह कहता है "एक सूची या सीमांकित स्ट्रिंग को देखते हुए," यह सुनिश्चित नहीं है कि यह कितना लंबा है, हालांकि (मुझे लगता है कि चुनौती पहली बार पोस्ट की गई थी)।

— ETHproductions

अच्छा है! का उपयोग करना hएक अच्छा विचार था। मैं आपकी तकनीक का उपयोग करके £ XhUg¯Y using1 £g´Y ¯1 +XÅ बन सकता हूं ।

— ओलिवर

5

हास्केल , 43 बाइट्स

p%((a:b):r)=(p:b):a%r
_%e=e
(%)=<<head.last

इसे ऑनलाइन आज़माएं! इनपुट और आउटपुट के लिए तार की एक सूची का उपयोग करता है।

पिछले शब्द के पहले अक्षर को याद करता है p, और श्रृंखला के नीचे नया पहला अक्षर भेजते हुए पुन: इसे वर्तमान शब्द का पहला अक्षर बनाता है। पिछले पहले अक्षर को अंतिम शब्द के पहले अक्षर के रूप में आरंभीकृत किया जाता है।

— XNOR
स्रोत

4

रूबी, 85 77 63 बाइट्स

बहुत यकीन है कि यह बहुत कम हो सकता है।

संपादित करें: इकट्ठा करने के लिए @manatwork के लिए धन्यवाद -> नक्शा

a=gets.split;$><<a.zip(a.rotate -1).map{|x,y|y[0]+x[1..-1]}*' '

— पीटर लेनकेफी
स्रोत

आप दोनों की जगह सकता है .collectऔर .eachसाथ .map।

— मैनटवर्क

1

-pझंडा (+1 बाइट) और i=-2;gsub(r=/\b\w/){$_.scan(r)[i+=1]}अंतिम गोल्फ के लिए

— मूल्य इंक

4

जेली , 6 बाइट्स

Ḣ€ṙ-;"

इसे ऑनलाइन आज़माएं!

नियमों को मुझसे बेहतर पढ़ने के लिए डेनिस के लिए धन्यवाद , यह शब्दों की एक सूची देता है। यह एक पूर्ण कार्यक्रम के रूप में काम नहीं करता है।

— आउटग्रॉफर को एरिक करें
स्रोत

4

CJam , 12 10 9 बाइट्स

Jimmy23013 को 1 बाइट धन्यवाद दिया

q~Sf+:()o

शब्दों की सूची के रूप में इनपुट लेता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

     e# Example input: ["Good" "afternoon," "World!"]
q~   e# Read and eval the input.
     e# STACK: [["Good" "afternoon," "World!"]]
Sf+  e# Append a space to each word.
     e# STACK: [["Good " "afternoon, " "World! "]]
:(   e# Remove the first character from each substring.
     e# STACK: [["ood " 'G "fternoon, " 'a "orld! " 'W]]
)o   e# Remove and print the last element of the array.
     e# STACK: [["ood " 'G "fternoon, " 'a "orld! "]]
     e# Implicitly join the remaining array with no separator and output.

— बिजनेस कैट
स्रोत

आप एक सूची के रूप में इनपुट और आउटपुट ले सकते हैं, आप जानते हैं।

— कॉमरेड स्पार्कलेपनी

@ComradeSparklePony आपने पुष्टि की कि मैंने जवाब देने के बाद: पी गोल्फिंग अब

— बिजनेस कैट

)oके लिए 1m>।

— jimmy23013

3

वी , 7 बाइट्स

Îxjp
{P

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

Î       " On every line:
 x      "   Delete the first character
  j     "   Move down a line
   p    "   And paste a character (into column 2)
{       " Move to the beginning of the input
 P      " And paste the last thing we deleted (into column 1)

— DJMcMayhem
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 46 बाइट्स

s=>s.map((k,i)=>s.slice(i-1)[0][0]+k.slice(1))

इस तथ्य का लाभ उठाता है जो slice(-1)किसी सरणी के अंतिम तत्व को लौटाता है।

टुकड़ा

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

f =

s=>s.map((k,i)=>s.slice(i-1)[0][0]+k.slice(1))

console.log(f(['Good', 'afternoon,', 'World!']));
console.log(f(['This', 'is', 'a', 'long', 'sentence.']));
console.log(f(['Programming', 'Puzzles', 'and', 'Code', 'Golf']));
console.log(f(['Input', '->', 'output']));
console.log(f(['The', 'quick', 'brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog.']));
console.log(f(['good', 'green', 'grass', 'grows.']));

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

क्या आप जुड़ाव हटा सकते हैं? प्रश्न बताता है कि आप एक सूची का उत्पादन कर सकते हैं। यह 8 बाइट्स बचाएगा

— क्रेग आयरे

1

@ क्रेगएयर, स्वीट, थैंक्स!

— रिक हिचकॉक

3

विम, 16 , 9 बाइट्स

<C-v>GdjPGD{P

7 बाइट्स ने @Wossname को धन्यवाद दिया!

प्रति पंक्ति एक शब्द इनपुट लेता है, जैसे

Hello
world
and
good
day
to
you

मेरा मानना है कि इनपुट लेने के बाद से यह ठीक होना चाहिए क्योंकि सूची की अनुमति है।

इसे ऑनलाइन आज़माएं!

— DJMcMayhem
स्रोत

यह 12 कीस्ट्रोक्स में किया जा सकता है यदि आप इसे 'हाथ से' करते हैं जैसे कि यह था। यकीन नहीं है कि कैसे इस वाक्यविन्यास को यहाँ स्पष्ट किया जाए या यदि यह इस पहेली में ऐसा करने के लिए भी मान्य है। ^vGdjPGd$ggP (जहां ^ v [[कंट्रोल + वी] कुंजी कॉम्बो है, बस शीर्ष बाईं ओर कर्सर के साथ शुरू करना और कमांड मोड में होना सुनिश्चित करें)

— Wossname

@Wossname आह, यह एक महान विचार है! एक जोड़ी छोटी चीजें हैं जो मैंने और भी बाइट्स (उदाहरण के लिए dd -> D, gg -> }) को बचाने के लिए जोड़ीं, टिप के लिए धन्यवाद!

— DJMcMayhem

मुझे नहीं पता था कि dd और gg दोनों के छोटे संस्करण हैं! बहुत बढ़िया :)

— Wossname

"<Cv>" के बजाय कोड में अक्षर v के आसपास "सुपरस्क्रिप्ट एचटीएमएल टैग" का उपयोग कैसे करें? जब उत्तर में देखा जाएगा तो कोड सही लंबाई दिखाई देगा। तो आपका कोड ऐसा दिखेगा ... <सुप> V </ sup> GdjPGD {P ... जो स्टैटेक्सचेंज वेब पेज को ठीक से प्रारूपित करने पर बहुत साफ-सुथरा दिखता है।

— वासनामे

1

मैं देख रहा हूं, घुंघराले ब्रेसिज़ पैराग्राफ के बीच में कूदते हैं, यह यहां काम करता है क्योंकि हम केवल एक पैराग्राफ के साथ काम कर रहे हैं। ठंडा। ओह वाह कि बड़ी कोड फ़ाइलों के माध्यम से जल्दी स्क्रॉलिंग करता है वास्तव में आसान! उस टिप के लिए धन्यवाद। :)

— वासनामे

3

> <> , 44 45 बाइट्स

90.f3+0.>&i&01.>~r&l0=?;o20.
 i:" "=?^:1+ ?!^

अंतरिक्ष-पृथक शब्द मानता है।

हारून द्वारा सुधार 1 बाइट जोड़ा गया

— AGourd
स्रोत

2

पायथन 2, 74 बाइट्स

इसे ऑनलाइन आज़माएं

S=input().split()
print' '.join(b[0]+a[1:]for a,b in zip(S,S[-1:]+S[:-1]))

-5 बाइट्स, @Rod को धन्यवाद

— मृत पोसुम
स्रोत

@Rod अच्छा सुझाव, धन्यवाद!

— मृत पोसुम

4

S[:-1]को छोटा किया जा सकता है S; जिप्पी

— वुल्फ

2

हास्केल , 50 बाइट्स

f=zipWith(:).((:).last<*>init).map head<*>map tail

इनपुट और आउटपुट शब्दों की सूची के रूप में हैं।

— faubi
स्रोत

1

कार्य अनाम हो सकते हैं, इसलिए आप इसे छोड़ सकते हैं f=।

— nimi

1

ओह, अच्छा, मुझे नहीं पता था कि हास्केल के लिए एक ऑनलाइन कंपाइलर था। मैं अपनी टिप्पणियां हटा दूंगा, क्योंकि मैं गलत हूं ^ ^

— निधि मोनिका का मुकदमा

2

PHP, 62 बाइट्स

$c=end($_GET);foreach($_GET as$g)echo$g|$g[0]=$c^$g^$c=$g,' ';

— user63956
स्रोत

2

सी #, 78 77 बाइट्स

using System.Linq;a=>a.Select((s,i)=>a[i-->0?i:a.Count-1][0]+s.Substring(1));

एक Func<List<string>, IEnumerable<string>>, पूर्ण / स्वरूपित संस्करण के संकलन :

using System;
using System.Collections.Generic;
using System.Linq;

class P
{
    static void Main()
    {
        Func<List<string>, IEnumerable<string>> f = a =>
                a.Select((s, i) => a[i-- > 0 ? i : a.Count - 1][0] + s.Substring(1));

        Console.WriteLine(string.Join(" ", f(new List<string>() { "Good", "afternoon,", "World!" })));
        Console.WriteLine(string.Join(" ", f(new List<string>() { "This", "is", "a", "long", "sentence." })));

        Console.ReadLine();
    }
}

— TheLethalCoder
स्रोत

2

ब्रेकीलॉग , 12 बाइट्स

{hᵐ↻|bᵐ}ᶠzcᵐ

इसे ऑनलाइन आज़माएं!

व्याख्या

Example input: ["Good","afternoon,","World!"]

{      }ᶠ       Find: [["W","G","a"],["ood","fternoon,","orld!"]]
 hᵐ↻              Take the head of each string, cyclically permute them
    |             (and)
     bᵐ           Get the strings without their heads
         z      Zip: [["W","ood"],["G","fternoon,"],["a","orld!"]]
          cᵐ    Map concatenate on each list: ["Wood","Gfternoon,","aorld!"]

— Fatalize
स्रोत

2

आर, 72 70 बाइट्स

function(x)paste0(substr(x,1,1)[c(y<-length(x),2:y-1)],substring(x,2))

इसे ऑनलाइन आज़माएं

2 बाइट्स ने Giuseppe को धन्यवाद दिया।

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

— user2390246
स्रोत

1

आप 2:y-1इसके बजाय का उपयोग कर सकते हैं 1:(y-1)क्योंकि आप 2 बाइट्स बचाता है, जिस :पर पूर्वता लेता है -।

— ग्यूसेप

substringएक समारोह तर्क के रूप में 69 बाइट्स

— Giuseppe

2

अजगर 2 + Numpy, 104 बाइट्स

from numpy import *
s=fromstring(input(),"b")
m=roll(s==32,1)
m[0]=1
s[m]=roll(s[m],1)
print s.tobytes()

— मिखाइल वी
स्रोत

1

आपको बाइट काउंट में आयात स्टेटमेंट को शामिल करना होगा। अच्छा जवाब!

— कॉमरेड स्पार्कलेपनी

इसके अलावा, आपको अपने इनपुट और आउटपुट कोड को बाइट काउंट में रखने की आवश्यकता है

— फेलिप नारदी बतिस्ता

1

मुझे लगता है कि आप अंतिम बाइटलाइन 1 बाइट के लिए छोड़ सकते हैं।

— अर्जन जोहान्स

@ BrjanJohansen हाँ, "u1" के बजाय "b" काम करता है, इसलिए -2 बाइट्स।

— मिखाइल वी

2

एपीएल (डायलॉग) , 6 बाइट्स

प्रति कॉलम एक शब्द के साथ मैट्रिक्स लेता है।

¯1∘⌽@1

इसे ऑनलाइन आज़माएं!

¯1∘⌽ एक कदम दाईं ओर घुमाएं

@ पर

1 पंक्ति 1

— एडम
स्रोत

चतुर इनपुट विचार

— जोना

1

गणितज्ञ, 59 बाइट्स

""<>#&/@Thread@{RotateRight@#~StringTake~1,#~StringDrop~1}&

इसे ऑनलाइन आज़माएं!

लेता है और शब्दों की एक सूची देता है।

यदि आप स्ट्रिंग्स लेना और वापस करना पसंद करते हैं, तो यह 87 बाइट्स के लिए काम करता है:

StringRiffle[Thread@{RotateRight@#~StringTake~1,#~StringDrop~1}&@StringSplit@#," ",""]&

— पेड़ नहीं
स्रोत

1

रेटिना, 46 37 31 बाइट्स

(\S)(\S* +)
$2$1
(.* .)(.)
$2$1

इसे ऑनलाइन आज़माएं

अभी भी गोल्फ हो रहा है ।।

— गणित के दीवाने
स्रोत

1

आप नहीं छोड़ा जा सकता (.*)और $3?

— नील

@ नील हां, धन्यवाद

— गणित

यदि आप +पहली पंक्ति में मोड़ते हैं तो आप तीसरी पंक्ति में -2 बाइट्स के लिए *मुड़ते हैं । इसे ऑनलाइन आज़माएं! (.* .)(.*)

— पुनपुन 1000

1

kdb +, 25 22 बाइट्स

समाधान:

rotate[-1;1#'a],'1_'a:

उदाहरण:

q)rotate[-1;1#'a],'1_'a:("The";"quick";"brown";"fox";"jumped";"over";"the";"lazy";"dog.")
"dhe"
"Tuick"
"qrown"
"box"
"fumped"
"jver"
"ohe"
"tazy"
"log."

स्पष्टीकरण:

1_'a:             // (y) drop first character of each element of a
,'                // join each left with each right
rotate[-1;1#'a]   // (x) take first character of each element of a, rotate backwards 1 char

अतिरिक्त:

एक संस्करण जो एक नियमित स्ट्रिंग लेता है (37 बाइट्स):

q){" "sv rotate[-1;1#'a],'1_'a:" "vs x}"The quick brown fox jumped over the lazy dog."
"dhe Tuick qrown box fumped jver ohe tazy log."

— streetster
स्रोत

1

पर्ल 5 , 40 बाइट्स

कोड + 1 के लिए 39 बाइट्स -a

$F[-1]=~/./;$a=$&,s/./$a/ for@F;say"@F"

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

0

रेटिना , 25 20 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

Om$`^.((?=.*¶))?
$#1

इसे ऑनलाइन आज़माएं!

इनपुट और आउटपुट लाइनफीड-पृथक हैं। परीक्षण सूट अंतरिक्ष-पृथक्करण से आवश्यक I / O रूपांतरण करता है।

— मार्टिन एंडर
स्रोत

लाइनफीड जुदाई का उपयोग करना ठीक है।

— कॉमरेड स्पार्कलपनी

0

गणितज्ञ, 134 बाइट्स

(w=Characters@StringSplit@#;d=Drop[w,0,1];StringRiffle[StringJoin/@Table[PrependTo[d[[i]],RotateRight[First/@w][[i]]],{i,Length@w}]])&

— J42161217
स्रोत

0

पायथ, 12 बाइट्स

.b+hNtY.>Q1Q

शब्दों की एक सूची लेता है और शब्दों की एक सूची देता है।

कोशिश करो!

— KarlKastor
स्रोत

0

जावा (ओपनजेडके 8) , 97 बाइट्स

for(int n=s.length,i=0,j=n-1;i<n;j%=n)System.out.print(s[j++].charAt(0)+s[i++].substring(1)+" ");

इसे ऑनलाइन आज़माएं!

— बैशफुल बेलुगा
स्रोत

यह एक स्निपेट है, एक फ़ंक्शन नहीं है। इसके अलावा, आपको पूरे स्ट्रिंग को एक तर्क के रूप में लेना चाहिए, और आउटपुट में कॉमा और प्रश्न / परीक्षा के निशान भी रखें।

— केविन क्रूज़सेन

0

सी, 106 77 बाइट्स

i,a,b;f(char*o){a=*o;for(i=0;o[i++];)if(o[i]==32){b=o[++i];o[i]=a;a=b;}*o=a;}

स्कॉचनेट से -29 बाइट्स

स्ट्रिंग को जगह में संशोधित करता है।

Ungolfed:

char *f(char *o){
    char a=*o,b; // start with a as the first character of the first word
    for(int i=0;++i<strlen(o);){
        // iterate through the string with i as the index
        if(o[i]==32){ // if the current character is a space, 
                      // i.e. if a word begins after this character
            b=o[++i]; // store the beginning of the next word in b
            o[i]=a; // set the beginning of the next word to a
            a=b; // set a to what the beginning of the next work used to be
        }
    }
    *o=a; 
    // set the beginning of the first word to the old beginning of the last word
}

— pizzapants184
स्रोत

गोल्फर संस्करण प्रस्ताव (ठीक उसी कोड): -29 बाइट्स

— स्कूटनीट

74 बाइट्स

— छत

0

जे , 34 बाइट्स

;@(,.~_1|.])~/@|:@(split;.2)@,&' '

इसे ऑनलाइन आज़माएं!

— FrownyFrog
स्रोत

0

भूसी , 11 बाइट्स

Foz:ṙ_1TmΓ,

इनपुट और आउटपुट स्ट्रिंग्स की एक सूची के रूप में, इसे ऑनलाइन आज़माएं!

_{(हेडर सिर्फ इनपुट को शब्दों की सूची में बदल देता है और आउटपुट सूची को रिक्त स्थान के साथ जोड़ देता है।)}

व्याख्या

F(z:ṙ_1)TmΓ,  -- example input: ["Good" "afternoon,","World!"]
         m    -- map the following (example on "Good")
          Γ   -- | pattern match head & tail: 'G' "ood"
           ,  -- | construct tuple: ('G',"ood")
              -- : [('G',"ood"),('a',"fternoon,"),('W',"orld!")]
        T     -- unzip: ("GaW",["ood","fternoon,","orld!"])
F(     )      -- apply the function to the pair
    ṙ_1       -- | rotate first argument by 1 (to right): "WGa"
  z:          -- | zip the two by (example with 'W' and "ood")
              -- | | cons/(re)construct string: "Wood"
              -- :-: ["Wood","Gfternoon,","aorld!"]

वैकल्पिक, 11 बाइट्स

§oz:ṙ_1m←mt

इसे ऑनलाइन आज़माएं!

— ბიმო
स्रोत

0

AWK , 63 बाइट्स

{for(R=substr($NF,1,1);++j<=NF;R=r)sub(r=substr($j,1,1),R,$j)}1

इसे ऑनलाइन आज़माएं!

ऐसा लगता है कि अतिरेक को कम करने का एक तरीका होना चाहिए, लेकिन मैं इसे नहीं देख रहा हूं।

नोट: TIO लिंक में मल्टीलाइन इनपुट के लिए 4 अतिरिक्त बाइट्स हैं।

— रॉबर्ट बेन्सन
स्रोत

वह प्यासा भ्रूण!

05AB1E , 7 6 बाइट्स

जाप , ११ १० ९ by बाइट्स

व्याख्या

हास्केल , 43 बाइट्स

रूबी, 85 77 63 बाइट्स

जेली , 6 बाइट्स

CJam , 12 10 9 बाइट्स

व्याख्या

वी , 7 बाइट्स

जावास्क्रिप्ट (ईएस 6), 46 बाइट्स

विम, 16 , 9 बाइट्स

> <> , 44 45 बाइट्स

पायथन 2, 74 बाइट्स

हास्केल , 50 बाइट्स

PHP, 62 बाइट्स

सी #, 78 77 बाइट्स

ब्रेकीलॉग , 12 बाइट्स

व्याख्या

आर, 72 70 बाइट्स

अजगर 2 + Numpy, 104 बाइट्स

एपीएल (डायलॉग) , 6 बाइट्स

गणितज्ञ, 59 बाइट्स

रेटिना, 46 37 31 बाइट्स

kdb +, 25 22 बाइट्स

पर्ल 5 , 40 बाइट्स

रेटिना , 25 20 बाइट्स

गणितज्ञ, 134 बाइट्स

पायथ, 12 बाइट्स

जावा (ओपनजेडके 8) , 97 बाइट्स

सी, 106 77 बाइट्स

जे , 34 बाइट्स

भूसी , 11 बाइट्स

व्याख्या

वैकल्पिक, 11 बाइट्स

AWK , 63 बाइट्स