精华内容
下载资源
问答
  • 源码在linux里面编译测试通过,判断t字符串是否是s字符中的字符重新排序组合的。 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <...

    源码在linux里面编译测试通过,判断t字符串是否是s字符中的字符重新排序组合的。

    
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <time.h>
    
    #define DEBUG	0
    
    #define true	0
    #define false	1
    
    
    int Deal_String(char *t, char *s)    //内存统计法,适用于字符多的情况下,字符少也行
    {
    	clock_t begin, end;
        	double cost;
    	begin = clock();
    	char *ss = s, *tt = t;
    	int flag = false;
    	int lengt = strlen(tt);
    	int lengs = strlen(ss);
    	if(lengt != lengs)
    		return false;
    	char *tram = malloc(128 * sizeof(char));
    	char *sram = malloc(128 * sizeof(char));
    	memset(tram, 0, (128 * sizeof(char)));
    	memset(sram, 0, (128 * sizeof(char)));
    	for(int i = 0; i < lengt; i++)
    	{
    		tram[*tt]++;
    		sram[*ss]++;
    		#if DEBUG
    		printf("tram[%d]=%d,sram[%d]=%d\n", *tt, tram[*tt], *ss, sram[*ss]);
    		#endif
    		tt++;
    		ss++;
    	}
    	if(memcmp(tram, sram , (128 * sizeof(char))))
    		flag = false;
    	else
     		flag = true;
    	free(tram);
    	free(sram);
    	end = clock();
        	cost = (double)(end - begin)/CLOCKS_PER_SEC;
        	printf("Time cost is: %lf secs\n", cost);
    	return flag;
    }
    
    
    
    int datcmp(void *a, void *b)
    {
    	return (*(char *)a > *(char *)b) ? 1 : -1;
    }
    
    
    int Deal_Str_Sort(char *t, char *s)    //排序统计法,适用于字符少的情况,排序直接调用C接口
    {
    	clock_t begin, end;
        	double cost;
    	begin = clock();
    
    	char *ss = s, *tt = t;
    	int flag = false;
    	int lengt = strlen(tt);
    	int lengs = strlen(ss);
    	if(lengt != lengs)
    		return false;
    	char *tram = malloc(lengt * sizeof(char));
    	char *sram = malloc(lengt * sizeof(char));
    	memset(tram, 0, (lengt * sizeof(char)));
    	memset(sram, 0, (lengt * sizeof(char)));
    	memcpy(tram, tt, lengt);
    	memcpy(sram, ss, lengt);
    	qsort(tram, lengt, sizeof(char), datcmp);
    	qsort(sram, lengt, sizeof(char), datcmp);
    	#if DEBUG
    	printf("T is:%s S is:%s\n", tram, sram);
    	#endif
    	if(!strncmp(tram, sram, lengt))
    		flag = true;
    	free(tram);
    	free(sram);
    	end = clock();
        	cost = (double)(end - begin)/CLOCKS_PER_SEC;
        	printf("Time cost is: %lf secs\n", cost);
    	return flag;
    		
    }
    
    
    
    int main(int argc, char **argv)
    {
    	if(argc != 4)
    	{
    		printf("Param Input Error!\n");
    		exit(1);
    	}
    	char *t = argv[1], *s = argv[2];
    	printf("T is %s,S is %s,method is %s\n", t, s, argv[3]);
    	if(!strcmp(argv[3], "memory"))
    	{
    		if(Deal_String(t, s))
    			printf("Is False\n");
    		else
    			printf("Is True\n");
    		return 0;
    	}
    	if(!strcmp(argv[3], "sort"))
    	{
    		if(Deal_Str_Sort(t, s))
    			printf("Is False\n");
    		else
    			printf("Is True\n");
    		return 0;
    	}
    	printf("Method Input Error !\n");
    	return 1;
    }
    

     

    Makefile 文件

    
    CC=gcc
    
    OBJECTS=strst.o
    BIN=test
    
    $(BIN):$(OBJECTS)
    	$(CC) $^ -o $@
    
    %.o:%.c
    	$(CC) -c $<
    
    
    help:
    	echo "./test heelo oohee"
    	echo "T is heelo"
    	echo "S is oohee"
    clean:
    	rm -fr $(OBJECTS)
    	rm -fr $(BIN) 
    

     

    运行示例:

    内存统计法:

    ./test hello olelo memory
    T is hello,S is olelo,method is memory
    Time cost is: 0.000013 secs
    Is False
     

    排序法:

    T is hello,S is olelo,method is sort
    Time cost is: 0.000039 secs
    Is False
     

    有此可见,两种算法都很快,对于时间的消耗都很少。

    展开全文
  • public static void main ( String[] args ) { boolean b = inIsideString("abcsfs", "bcss"); System.out.println(b);... * 输入两个字符串s和t,判断t是否可以通过删除若干字符得到s,例如:“abcsfs”可以删除部...

    输入两个字符串s和t,判断t是否可以通过删除若干字符得到s,例如:“abcsfs”可以删除部分字符得到"bcss" 

        public static void main ( String[] args ) {
            boolean b = inIsideString("abcsfs", "bcss");
            System.out.println(b);
        }
        /**
         * 输入两个字符串s和t,判断t是否可以通过删除若干字符得到s,例如:“abcsfs”可以删除部分字符得到"bcss"
         * @param s
         * @param t
         * @return
         */
        public static boolean inIsideString(String s,String t){
            char[] cs = s.toCharArray();
            char[] ct = t.toCharArray();
            if(cs.length<ct.length){
                return false;
            }
            int index=0;
            for (char cs1 : cs) {
                if(cs1==ct[index]){
                    index++;
                    if(index==ct.length){
                        return true;
                    }
                }
                continue;
            }
            return false;
        }

     

    展开全文
  • 给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。 示例1: 输入: s = "anagram", t = "nagaram" 输出: true 示例 2: 输入: s = "rat", t = "car" 输出: false 说明: 你...

    原题链接:https://leetcode-cn.com/problems/valid-anagram

    题目描述:

    给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。

    示例 1:

    输入: s = "anagram", t = "nagaram"
    输出: true

    示例 2:

    输入: s = "rat", t = "car"
    输出: false

    说明:
    你可以假设字符串只包含小写字母。

    解析:

    首先,我们要了解什么是字母异位词

    口水话就是长度一样,所含一样的字母就是字母异位词,由这个思路我们知道,长度不一样那么直接pass,这是一个前提,长度一样才能进行下面的判断。之后就是我们如何判断所含字母一样呢?,我的想法是用数组,然后进行排列,把他们排列的结果一一对比就行了。

    数组排列的方法为 Arrays.sort(s),转化数组的方法为 toCharArray(s);数组的比较方法为Arrays.equals(s,t);

    有了以上的方法我们做题目就得心应手了

    实现代码

    class Solution {
        public boolean isAnagram(String s, String t) {
            
            char[] ss = s.toCharArray();//将s字符串转换为数组
            char[] tt = t.toCharArray();//将t字符串转换为数组
            
            if(ss.length != tt.length) return false;//长度不等,直接pass
            
            Arrays.sort(ss);//排列组合
            Arrays.sort(tt);
            
            return Arrays.equals(ss,tt);//看他们各自拼接的组合有无相等的可能
            
        }
    }

    输出:

    展开全文
  • 前几天看了《C++11之美》受到一些启发,想到可以通过判断一个类型是否有指定的操作符(比如==,>=)。 基本的原理与文中的差不多,利用SFINAE原则,通过返回类型后置来推断表达式的类型,推断的过程中利用declval,它...

    前几天看了《C++11之美》受到一些启发,想到可以通过判断一个类型是否有指定的操作符(比如==,>=)。
    基本的原理与文中的差不多,利用SFINAE原则,通过返回类型后置来推断表达式的类型,推断的过程中利用declval,它可以获取类型的右值引用,以便来调用==操作符,这个过程是在编译期完成的。
    如果通过==操作符比较declval的右值引用成功了,则会继续推断逗号表达式的类型,最终推断的函数返回类型为bool
    如果通过==操作符比较declval的右值引用失败了,则推断失败,编译器会选择优先级最低的test(...)函数,它的返回类型为void
    我们最后判断实例化的test<T>(0)的返回值是否为bool,可以知道类型T是否存在==操作符。

    template <typename T>
    struct has_equal_operator{
        template<typename U>  static auto test(int)->   decltype(declval<U>()==declval<U>());
        //template<typename U> static auto test(int)->  decltype(declval<U>().operator==(declval<U>()));
        template<typename U> static void test(...);
        enum{value=std::is_same<decltype(test<T>(0)), bool>::value};
    };

    在上面代码中,推导test(int)返回类型的表达式是由执行==操作符比较两个declval获取的右值引用来实现的。有两种方式 declval<U>()==declval<U>()declval<U>().operator==(declval<U>())
    第一种是真接按常用的==操作符用法写的==表达式,第二种则是把操作符==作为一个类成员函数来调用。两种表达式判断是有区别的:

    第一种方式可以用于判断基本数据类型和class类型。
    对于基本数据类型(比如int),因为没有成员函数,所以第二种方式对于基本类型返回的肯定是false.无法用这种方式判断基本数据类型是否有==操作符,只适用于class类型。

    基于上面这个元函数的原理,我们还可以继续写出其他操作符的判断函数,比如>,*操作符。
    下面是完整的代码

    #include <iostream>
    #include <type_traits>
    using namespace std;
    
    struct  test_classA{
        int a;
        virtual bool operator==(const test_classA&v){
            return a==v.a;
        }
        virtual ~test_classA()=default;
    };
    struct test_classB:test_classA{
    };
    struct test_classC:test_classB{
    };
    template <typename T>
    struct has_equal_operator{
        template<typename U>  static auto test(int)->   decltype(declval<U>()==declval<T>());
        //template<typename U> static auto test(int)->  decltype(declval<U>().operator==(declval<T>()));
        template<typename U> static void test(...);
        enum{value=std::is_same<decltype(test<T>(0)), bool>::value};
        //通过判断test<T>(0)返回值是否为bool来判断是否有==操作符
    };
    template <typename T>
    struct has_asterisk_operator{
        template<typename U> static auto test(int)->    decltype(*declval<U>());
        template<typename U> static void test(...);
        enum{value=std::is_reference<decltype(test<T>(0))>::value};
        //通过判断test<T>(0)返回值是否为引用来判断是否有*操作符
    };
    template <typename T>
    struct has_gt_operator{
        template<typename U> static auto test(int)->    decltype(declval<U>()>declval<U>());
        template<typename U> static void test(...);
        enum{value=std::is_same<decltype(test<T>(0)), bool>::value};
        //通过判断test<T>(0)返回值是否为bool来判断是否有>操作符
    };
    
    int main()
    {
        cout<<"int has operator> :"<<has_gt_operator<int>::value<<endl;
        cout<<"int* has operator> :"<<has_gt_operator<int*>::value<<endl;
        cout<<"test_class has operator> :"<<has_gt_operator<test_classA>::value<<endl;
    
        cout<<"int has operator* :"<<has_asterisk_operator<int>::value<<endl;
        cout<<"int* has operator* :"<<has_asterisk_operator<int*>::value<<endl;
    
        cout<<"int has operator== :"<<has_equal_operator<int>::value<<endl;
        cout<<"test_class has operator== :"<<has_equal_operator<test_classA>::value<<endl;
        cout<<"test_classC has operator ==:"<<has_equal_operator<test_classC>::value<<endl;
        cout<<"hasequal<double> has operator== :"<<has_equal_operator<has_equal_operator<double>>::value<<endl;
    }
    

    下面是has_equal_operator的使用场景的例子:

        /* 判断obj1,obj2是否相等
         * 如果K有==操作符则使用==比较版本,否则使用default_equals函数进行二进制比较
         */
        template<typename _K=K>
        typename std::enable_if<!has_equal_operator<_K>::value,bool>::type equals(const _K &obj1, const _K &obj2)const {
            return 0 == default_equals(&obj1, &obj2, sizeof(_K));
        }
        template<typename _K=K>
        typename std::enable_if<has_equal_operator<_K>::value,bool>::type equals(const _K &obj1, const _K &obj2)const {
            return obj1==obj2;
        }

    后记:

    本文在C++论坛发出后,经网友akirya提醒才知道 std::is_assignable其实就是采用本文类似的原理。
    看来还是对STL提供的元函数不熟悉,否则如果早想到看看std::is_assignable的源码,就不会花这么时间了。
    下面是gcc的std::is_assignable相关源码:

      template<typename _Tp, typename _Up>
        class __is_assignable_helper
        {
          template<typename _Tp1, typename _Up1,
               typename = decltype(declval<_Tp1>() = declval<_Up1>())>
        static true_type
        __test(int);
    
          template<typename, typename>
        static false_type
        __test(...);
    
        public:
          typedef decltype(__test<_Tp, _Up>(0)) type;
        };
    
    展开全文
  • 给定一个整数,编写一个函数来判断它是否是 2 的幂次方。 示例 1: 输入 : 1 输出 : true  解释 : 20 = 1 示例 2 :  输入 : 16  输出 : true  解释 : 24 = 16 示例 3 : 输入 : 218  输出 : false   解题...
  • 在java里面对象T不能用T.equals(null)方法判断是否T泛型是否为null 因为如果T为null,他是不存在任何方法的,包括equals,所以当T为null时,使用T.equals()就会报空指针错误。在equals源码里面也明确表示"non-null ...
  • 给定字符串 s 和 t判断 s 是否为 t 的子序列。 你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长(长度 ~= 500,000),而 s 是个短字符串(长度 <=100)。 字符串的一个子序列是原始字符串删除...
  • 节假日每年都不一样,没有特定的规律,所以需要手工做配置,在数据库中建一张holiday表记录节假日,包括周六...T+0:如果T是节假日,则相当于T+1 T+n:接下来的第n个工作日 import java.util.Date; import ja...
  • 《C程序设计语言》5-4 题目:编写函数strend(s, t)。如果字符串t出现在字符串s的尾部,该函数返回1,否则.../*判断字符串t是否在s的尾部*/ int strend(char *s, char *t); int main() {  char s[] = "yjygirl...
  • 给定字符串 s 和 t判断 s 是否为 t 的子序列。 你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长(长度 ~= 500,000),而 s 是个短字符串(长度 <=100)。 字符串的一个子序列是原始字符串删除...
  • 1: public static bool IsDefault<T>(this T value) 2: { 3: /... 如果用==直接判断(default(T) == value),编译时会提示错误:Error CS0019: 运算符“==”无法应用于“T”和“T”类型的操作数 (CS0019)。 ...
  • Flutter判断泛型类型

    千次阅读 2020-02-15 15:54:57
    在Dart中判断泛型类型时可以用如下方法: void main() { test<... //判断T是否为某一类型或其子类 print(List<T>() is List<num>); //得到T的类型 print(typeOf<T>()); ...
  • 在SPSS中独立样本T检验所检验的是独立样本,配对样本T检验检验的是相关样本。如何判断是独立样本还是相关样本呢? 举例说明: (独立样本)“已知人们一般状况下的脉搏。考察焦虑状况下人的脉搏与一般状况下的有无差别...
  • go中判断空字符串、nil和len(t)的用法

    千次阅读 2020-06-19 18:59:36
    我们在实际生产中经常会遇到判断各种为空的情况,那在go中""、nil、len(t) = 0 三种空分别在什么地方下使用的呢,下面我们来看下: 1、"" 一般是判断一个string字符串是否为空 var t string if t == "" { fmt....
  • C#一句话判断两个List<T>是否相等

    万次阅读 2015-01-28 13:17:52
    没有营养的水文一篇,呵呵~~假设有两个List对象 ,List1和List2,如下方法判断两都是否相等List1.All(List2.Contains)
  • 定义指针i指向s的第一个元素,定义j指向t的第一个元素。若s[i] == t[j],则i,j都后移。若不等,则j后移。   代码:   结果:   不是很快。   另一...
  • C++对输入string字符串进行格式判断并转化为time_t时间戳 前言 学校实验要求输入一个时间段,在此时间段内进行查询统计。 我的思路是规定格式,让用户按照格式分别输入开始时间和结束时间,对时间格式进行判断,为...
  • T1037 判断一个数能否同时被3和5整除 做题之前我们先来仔细的阅读以下题目 一 流程图 二 编程 在这里要使整数‘n’能同时被3和5整除用与‘&&’连接 代码 #include<iostream> using namespace std; ...
  • //判断T是否为某一类型或其子类 print(List<T>() is List<num>); //得到T的类型 print(typeOf<T>()); } static Type typeOf<T>() => T; 注意这个在dartpad中是无法运行的 ...
  • Linq语句中IEnumerable <T>判断为空办法

    千次阅读 2019-06-09 15:38:45
    判断集合办法 参考文章:https://blog.csdn.net/u010178308/article/details/77681573 在使用LINQ语句的时候会生成IEnumerable source的集合,在查询集合是否为空的时候一般采用 source.count()的办法进进行查询,...
  • 给定三个正整数,分别表示三条线段的长度,判断这三条线段能否构成一个三角形。如果能构成三角形,则输出“yes”,否则输出“no”。 【输入】 输入共一行,包含三个正整数,分别表示三条线段的长度,数与数之间以...
  • 判断某年是否是闰年。如果公元a年是闰年输出Y,否则输出N。 【输入】 输入只有一行,包含一个整数a(0 < a < 3000)。 【输出】 一行,如果公元a年是闰年输出Y,否则输出N。 【输入样例】 2006 【输出...
  • 最近学习非参数统计,碰到一个样例,准确说明了若数据不服从正态分布,或有明显的偏态表现,应用t统计量和t检验推断未必能发挥较好的效果~ 这是一个课本上的例题,数据是16座预售楼盘均价,判断是否与媒体公布的37...
  • pps:余数是在dx中吧,我拿dx和0比较来判断奇偶没问题吧? // test.cpp : Defines the entry point for the console application. // #include "stdafx.h" int _tmain(int argc, _TCHAR* argv[]) { ...
  • java判断List<T>对象是否唯一、去重复

    千次阅读 2016-10-09 15:31:41
    java中List去重复方法(前提:T对象中需要重写equals方法) /** * List去重复 * 需要重写T中的Equals及GetHashCode方法 * @param a * @return */ public static List array_unique(List list) { List...
  • #include #include ...//基本模板,一般情况下T不是基本类型 template class IsFundaT {  public:  enum { Yes=0, No=1 }; }; //用于特化基本类型的宏 #define MK_FUNDA_TYPE(T) \  

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,412
精华内容 10,564
关键字:

判断t