Pascal 解法, 执行用时: 1ms, 内存消耗: 256KB, 提交时间: 2018-09-15

var
    l:array[0..200] of longint;
    s:array[0..200] of string[150];
    n,i:longint;
    f1,f2:boolean;
begin
    readln(n);
    for i:=1 to n do
    begin
        readln(s[i]);
        l[i]:=length(s[i]);
    end;
    f1:=true; f2:=true;
    for i:=2 to n do
        if s[i]<s[i-1] then
        begin
            f1:=false;
            break;
        end;
    for i:=2 to n do
        if l[i]<l[i-1] then
        begin
            f2:=false;
            break;
        end;
    if f1 and f2 then writeln('both')
    else if f1 then writeln('lexicographically')
        else if f2 then writeln('lengths')
            else writeln('none');
end.

C 解法, 执行用时: 1ms, 内存消耗: 336KB, 提交时间: 2021-07-22

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

#define not !

// 优化版的冒泡排序
void* bubble_sort(void* __base,
                  const size_t __nmemb,
                  const size_t __size,
                  int (*__cmp) (const void*, const void*));

// According to 字串字典序比较字串间的优先关系
int comp_by_str_lexicographically(const void* s1, const void* s2);

// According to 字串长度比较字串间的优先关系
int comp_by_str_len(const void* s1, const void* s2);

// 复制字串数组
void clone_strs(char** destination, const char** source, const size_t size);

void swap(const void* a, const void* b, const size_t __size);

int str_len(const char* s);

int main(const int argc, const char** const argv) {
  int n;
  scanf("%d", &n);
  char* strs[100];
  
  int i;
  for (i = 0; i < n; ++i) {
    *(strs + i) = (char*) malloc(101 * sizeof(char));
    scanf("%s", *(strs + i));
  }
  
  char *strs2[100], *strs3[100];
  for (i = 0; i < n; ++i) {
    *(strs2 + i) = (char*) malloc(101 * sizeof(char));
    *(strs3 + i) = (char*) malloc(101 * sizeof(char));
  }
  clone_strs(strs2, strs, n);
  clone_strs(strs3, strs, n);
 
  bubble_sort(strs2, n, sizeof(char*), comp_by_str_lexicographically);
  bubble_sort(strs3, n, sizeof(char*), comp_by_str_len);
  
  int sorted_by_lexicographically = 1, sorted_by_len = 1;
  for (i = 0; i < n; ++i) {
    if (strcmp(*(strs2 + i), *(strs + i))) {
      sorted_by_lexicographically = 0;
      break;
    }
  }
  for (i = 0; i < n; ++i) {
   if (strcmp(*(strs3 + i), *(strs + i))) {
      sorted_by_len = 0;
      break;
    }
  }
  
  if (sorted_by_lexicographically && sorted_by_len) puts("both");
  else if (sorted_by_lexicographically)             puts("lexicographically");
  else if (sorted_by_len)                           puts("lengths");
  else                                              puts("none");

  return 0;
}

void* bubble_sort(void* __base,
                  const size_t __nmemb,
                  const size_t __size,
                  int (*__cmp) (const void*, const void*)) {
  
  int t, i, exchange;
  for (t = 0; t < __nmemb - 1; ++t) {
    exchange = 0;
    for (i = 0; i < __nmemb - 1 - t; ++i) {
      if (__cmp((char*) __base + i * __size, (char*) __base + (i + 1) * __size) > 0) {
        swap((char*) __base + i * __size, (char*) __base + (i + 1) * __size, __size);
        exchange = 1;
      }
    }
    
    if (not exchange) break;
  }
  
  return __base;
}

void swap(const void* a, const void* b, const size_t __size) {
  int i;
  for (i = 0; i < __size; ++i) {
    *((char*) a + i) ^= *((char*) b + i);
    *((char*) b + i) ^= *((char*) a + i);
    *((char*) a + i) ^= *((char*) b + i);
  }
}

int comp_by_str_lexicographically(const void* s1, const void* s2) {
  return strcmp(*(char**) s1, *(char**) s2);
}

int comp_by_str_len(const void* s1, const void* s2) {
  return str_len(*(char**) s1) - str_len(*(char**) s2);
}

int str_len(const char* s) {
  assert(s);
  if (!*s) return 0;
  
  const char* p = s;
  while (*++p);
  
  return p - s;
}

void clone_strs(char** destination, const char** source, const size_t size) {
  int i;
  for (i = 0; i < size; ++i)
    strcpy(*(destination + i), *(source + i));
}