(B卷,100分)- 按单词下标区间翻转文章内容（Java & JS & Python & C）

题目描述

给定一段英文文章片段，由若干单词组成，单词间以空格间隔，单词下标从0开始。
请翻转片段中指定区间的单词顺序并返回翻转后的内容。

例如给定的英文文章片段为"I am a developer"，翻转区间为[0,3]，则输出“developer a am I”。

String reverseWords(String s, int start, int end)

输入描述

使用换行隔开三个参数

• 第一个参数为英文文章内容即英文字符串
• 第二个参数为待翻转内容起始单词下标
• 第三个参数为待翻转内容最后一个单词下标

输出描述

翻转后的英文文章片段所有单词之间以一个半角空格分隔进行输出。

备注

英文文章内容首尾无空格

用例

题目解析

本题主要考察数组常规操作，以及简单的双指针使用。

注意startIndex和endIndex的越界处理即可。

JavaScript算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const lines = [];
rl.on("line", (line) => {
  lines.push(line);

  if (lines.length == 3) {
    const s = lines[0];
    const startIndex = lines[1] - 0;
    const endIndex = lines[2] - 0;
    console.log(getResult(s, startIndex, endIndex));
    lines.length = 0;
  }
});

function getResult(s, startIndex, endIndex) {
  const sArr = s.split(" ");

  startIndex = Math.min(Math.max(0, startIndex), sArr.length - 1);
  endIndex = Math.min(Math.max(0, endIndex), sArr.length - 1);

  if (startIndex >= endIndex) return s;

  let l = startIndex;
  let r = endIndex;

  while (l < r) {
    const tmp = sArr[l];
    sArr[l] = sArr[r];
    sArr[r] = tmp;
    l++;
    r--;
  }

  return sArr.join(" ");
}

Java算法源码

import java.util.Scanner;
import java.util.StringJoiner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String s = sc.nextLine();
    int startIndex = Integer.parseInt(sc.nextLine());
    int endIndex = Integer.parseInt(sc.nextLine());
    System.out.println(getResult(s, startIndex, endIndex));
  }

  public static String getResult(String s, int startIndex, int endIndex) {
    String[] sArr = s.split(" ");

    startIndex = Math.min(Math.max(0, startIndex), sArr.length - 1);
    endIndex = Math.min(Math.max(0, endIndex), sArr.length - 1);

    if (startIndex >= endIndex) return s;

    int l = startIndex;
    int r = endIndex;
    while (l < r) {
      String tmp = sArr[l];
      sArr[l] = sArr[r];
      sArr[r] = tmp;
      l++;
      r--;
    }

    StringJoiner sj = new StringJoiner(" ");
    for (String t : sArr) sj.add(t);
    return sj.toString();
  }
}

Python算法源码

# 输入获取
s = input()
startIndex = int(input())
endIndex = int(input())


# 算法入口
def getResult(s, start, end):
    sArr = s.split()

    start = min(max(0, start), len(sArr) - 1)
    end = min(max(0, end), len(sArr) - 1)

    if start >= end:
        return s

    l = start
    r = end

    while l < r:
        sArr[l], sArr[r] = sArr[r], sArr[l]
        l += 1
        r -= 1

    return " ".join(sArr)


# 调用算法
print(getResult(s, startIndex, endIndex))

C算法源码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MIN(a,b) (a) < (b) ? (a) : (b)
#define MAX(a,b) (a) > (b) ? (a) : (b)

// 第一行输入的最大长度
#define MAX_INPUT_LINE_LENGTH 100000

// 动态数组初始容量
#define DEFAULT_CAPACITY 16

// 动态数组元素
typedef char* E;

// 动态数组结构体
typedef struct ArrayList {
    int size;
    int capacity;
    E* array;
} ArrayList;

// 创建动态数组
ArrayList* new_ArrayList();
// 向动态数组中加入元素
void add_ArrayList(ArrayList* list, E ele);

// 按指定分隔符delimiter分割字符串source
ArrayList* split(char* source, char* delimiter);
// 按指定分隔符delimiter拼接list中的元素
char* join(ArrayList* list, char* delimiter, int container_size);

char* reverseWords(char* s, int start, int end);

int main() {
    char s[MAX_INPUT_LINE_LENGTH];
    scanf("%[^n]", s);

    int start, end;
    scanf("%d %d", &start, &end);

    printf("%s", reverseWords(s, start, end));

    return 0;
}

char* reverseWords(char* s, int start, int end) {
    ArrayList * list = split(s, " ");

    start = MIN(MAX(0, start), list->size - 1);
    end = MIN(MAX(0, end), list->size - 1);

    if(start >= end) return s;

    int l = start;
    int r = end;

    while (l < r) {
        char* tmp = list->array[l];
        list->array[l] = list->array[r];
        list->array[r] = tmp;
        l++;
        r--;
    }

    return join(list, " ", MAX_INPUT_LINE_LENGTH);
}


ArrayList* split(char* source, char* delimiter) {
    // strtok 会改变字符串，因此这里对字符串进行拷贝
    char tmp[MAX_INPUT_LINE_LENGTH];
    strcpy(tmp, source);

    ArrayList* list = new_ArrayList();

    char* token = strtok(tmp, delimiter);
    while (token != NULL) {
        add_ArrayList(list, token);
        token = strtok(NULL, delimiter);
    }

    return list;
}

char* join(ArrayList* list, char* delimiter, int container_size) {
    char* container = (char*) calloc(container_size, sizeof(char));

    for(int i=0; i<list->size; i++) {
        char* ele = list->array[i];

        strcat(container, ele);

        if(i != list->size - 1) {
            strcat(container, delimiter);
        }
    }

    return container;
}

ArrayList* new_ArrayList() {
    ArrayList* list = (ArrayList*) malloc(sizeof(ArrayList));
    list->size = 0;
    list->capacity = DEFAULT_CAPACITY;
    list->array = (E*) malloc(sizeof(E) * DEFAULT_CAPACITY);

    for(int i=0; i<DEFAULT_CAPACITY; i++) {
        list->array[i] = NULL;
    }

    return list;
}

void add_ArrayList(ArrayList* list, E ele) {
    if(list->size == list->capacity) {
        int newCapacity = list->capacity << 1;

        void* p = realloc(list->array, sizeof(E) * newCapacity);
        if(p == NULL) exit(-1);

        list->array = (E*) p;
        list->capacity = newCapacity;
    }

    list->array[list->size] = ele;
    list->size++;
}