算法学习day08字符串part01-344541offer05151offer58

Posted 2023-05-09 lipin

package LeetCode.stringpart01;
/**
 * 344. 反转字符串
 * 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
 * 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
 * 示例：
 * 输入：s = ["h","e","l","l","o"]
 * 输出：["o","l","l","e","h"]
 * */
/**
 * 双指针
 * */
public class ReverseString_344 
    public static void main(String[] args) 
        char [] c = \'h\',\'e\',\'l\',\'l\',\'o\';
        reverseString(c);
        System.out.println(c);
    
    public static void reverseString(char[] s) 
        int l = 0;
        int r = s.length - 1;
        while(l < r)
            char temp = s[l];
            s[l] = s[r];
            s[r] = temp;
            l++;
            r--;
        
    

package LeetCode.stringpart01;
/**
 * 541. 反转字符串 II
 * 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
 * 如果剩余字符少于 k 个，则将剩余字符全部反转。
 * 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
 * 示例：
 * 输入：s = "abcdefg", k = 2
 * 输出："bacdfeg"
 * */
/**
 * 每隔2k个反转前k个，尾数不够k个时候全部反转
 * */
public class ReverseStringII_541 
    public static void main(String[] args) 
        String str = "abcdefg";
        int k = 2;
        String result = reverseStr(str,k);
        System.out.println(result);
    

    public static String reverseStr(String s, int k) 
        char[] ch = s.toCharArray();
        // 1. 每隔 2k 个字符的前 k 个字符进行反转
        for (int i = 0; i< ch.length; i += 2 * k) 
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= ch.length) 
                reverse(ch, i, i + k -1);
                continue;
            
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转
            reverse(ch, i, ch.length - 1);
        
        return  new String(ch);

    
    // 定义翻转函数
    public static void reverse(char[] ch, int i, int j) 
        for (; i < j; i++, j--) 
            char temp  = ch[i];
            ch[i] = ch[j];
            ch[j] = temp;
        

    

package LeetCode.stringpart01;
/**
 * 剑指 Offer 05. 替换空格
 * 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
 * 示例：
 * 输入：s = "We are happy."
 * 输出："We%20are%20happy."
 * */
public class ReplaceSpace_offer05 
    public static void main(String[] args) 
        String str = "We are happy.";
        String result = replaceSpace(str);
        System.out.println(result);
    

    public static String replaceSpace(String s) 
        if (s == null) 
            return null;
        
        //选用 StringBuilder 单线程使用，比较快，选不选都行
        StringBuilder sb = new StringBuilder();
        //使用 sb 逐个复制 s ，碰到空格则替换，否则直接复制
        for (int i = 0; i < s.length(); i++) 
            //s.charAt(i) 为 char 类型，为了比较需要将其转为和 " " 相同的字符串类型
            //if (" ".equals(String.valueOf(s.charAt(i))))
            if (s.charAt(i) == \' \') 
                sb.append("%20");
             else 
                sb.append(s.charAt(i));
            
        
        return sb.toString();
    

package LeetCode.stringpart01;
/**
 * 541. 反转字符串 II
 * 给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
 * 如果剩余字符少于 k 个，则将剩余字符全部反转。
 * 如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
 * 示例：
 * 输入：s = "abcdefg", k = 2
 * 输出："bacdfeg"
 * */
/**
 * 每隔2k个反转前k个，尾数不够k个时候全部反转
 * */
public class ReverseStringII_541 
    public static void main(String[] args) 
        String str = "abcdefg";
        int k = 2;
        String result = reverseStr(str,k);
        System.out.println(result);
    

    public static String reverseStr(String s, int k) 
        char[] ch = s.toCharArray();
        // 1. 每隔 2k 个字符的前 k 个字符进行反转
        for (int i = 0; i< ch.length; i += 2 * k) 
            // 2. 剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符
            if (i + k <= ch.length) 
                reverse(ch, i, i + k -1);
                continue;
            
            // 3. 剩余字符少于 k 个，则将剩余字符全部反转
            reverse(ch, i, ch.length - 1);
        
        return  new String(ch);

    
    // 定义翻转函数
    public static void reverse(char[] ch, int i, int j) 
        for (; i < j; i++, j--) 
            char temp  = ch[i];
            ch[i] = ch[j];
            ch[j] = temp;
        

    

package LeetCode.stringpart01;
/**
 * 剑指 Offer 58 - II. 左旋转字符串
 * 字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。
 * 比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
 * 示例：
 * 输入: s = "abcdefg", k = 2
 * 输出: "cdefgab"
 * */
/**
 * 思路：
 * 1.反转区间为前n的子串
 * 2.反转区间为n到末尾的子串
 * 3.反转整个字符串
 * */
public class ReverseLeftWords_offer58 
    public static void main(String[] args) 
       String s = "abcdefg";
       int k = 2;
       String result = reverseLeftWords(s,k);
       System.out.println(result);

    

    public static String reverseLeftWords(String s, int n) 
        int len=s.length();
        StringBuilder sb=new StringBuilder(s);
        reverseString(sb,0,n-1);
        reverseString(sb,n,len-1);
        return sb.reverse().toString();
    
    public static void reverseString(StringBuilder sb, int start, int end) 
        while (start < end) 
            char temp = sb.charAt(start);
            sb.setCharAt(start, sb.charAt(end));
            sb.setCharAt(end, temp);
            start++;
            end--;
        
    

 

python学习点滴记录-Day17-django-part2

• url配置系统之无名分组
• url配置系统之有名分组
• url配置系统之分发app
• url配置系统之url反向解析
• 视图函数之请求对象
• 视图函数之响应对象
• 模板语法之渲染变量
• 模板语法之变量过滤器
• ORM

 

URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL与要为该URL调用的视图函数之间的映射表；你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段代码。

    ‘‘‘
    
    urlpatterns = [
         url(正则表达式, views视图函数，参数，别名),
]


参数说明：

    一个正则表达式字符串
    一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
    可选的要传递给视图函数的默认参数（字典形式）
    一个可选的name参数

    ‘‘‘

 

2.1 URLconf的正则字符串参数

2.1.1 简单配置

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r‘^articles/2003/$‘, views.special_case_2003),
    url(r‘^articles/([0-9]{4})/$‘, views.year_archive),
    url(r‘^articles/([0-9]{4})/([0-9]{2})/$‘, views.month_archive),
    url(r‘^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$‘, views.article_detail),
]

    ‘‘‘
    NOTE:
    1 一旦匹配成功则不再继续
    2 若要从URL 中捕获一个值，只需要在它周围放置一对圆括号。
    3 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
    4 每个正则表达式前面的‘r‘ 是可选的但是建议加上。

一些请求的例子：

    /articles/2005/3/ 不匹配任何URL 模式，因为列表中的第三个模式要求月份应该是两个数字。
    /articles/2003/ 将匹配列表中的第一个模式不是第二个，因为模式按顺序匹配，第一个会首先测试是否匹配。
    /articles/2005/03/ 请求将匹配列表中的第三个模式。Django 将调用函数
                       views.month_archive(request, ‘2005‘, ‘03‘)。
    ‘‘‘

#设置项是否开启URL访问地址后面不为/跳转至带有/的路径
APPEND_SLASH=True

2.1.2 有名分组(named group)

上面的示例使用简单的、没有命名的正则表达式组（通过圆括号）来捕获URL 中的值并以位置 参数传递给视图。在更高级的用法中，可以使用命名的正则表达式组来捕获URL 中的值并以关键字 参数传递给视图。

在Python 正则表达式中，命名正则表达式组的语法是(?P<name>pattern)，其中name 是组的名称，pattern 是要匹配的模式。

下面是以上URLconf 使用命名组的重写：

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r‘^articles/2003/$‘, views.special_case_2003),
    url(r‘^articles/(?P<year>[0-9]{4})/$‘, views.year_archive),
    url(r‘^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$‘, views.month_archive),
    url(r‘^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$‘, views.article_detail),
]

这个实现与前面的示例完全相同，只有一个细微的差别：捕获的值作为关键字参数而不是位置参数传递给视图函数。例如：

    /articles/2005/03/    
    请求将调用views.month_archive(request, year=‘2005‘, month=‘03‘)函数
    /articles/2003/03/03/ 
    请求将调用函数views.article_detail(request, year=‘2003‘, month=‘03‘, day=‘03‘)。

在实际应用中，这意味你的URLconf 会更加明晰且不容易产生参数顺序问题的错误 —— 你可以在你的视图函数定义中重新安排参数的顺序。当然，这些好处是以简洁为代价；有些开发人员认为命名组语法丑陋而繁琐。