/tech/ - Tecnología

>>5441
Aquí un código que hice en C, no está optimizado pero sirve :
#include <stdio.h>
#include <string.h>
int main(){
int ex1=0,ex2=0,ex3=0,coincidencias=0;
char all_words[20][20];
char waifu_name[20];
char temporal;

scanf("%d",&ex1);
scanf("%s",waifu_name);
ex3=strlen(waifu_name);
for(int i=0;i<ex1;i++){
scanf("%s",all_words[i]);}

for(int a=0;a<ex1;a++){
ex2=strlen(all_words[a]);
for(int i=0;i<ex2;i++){
for(int j=0;j<ex2;j++){
if(strcmp(&all_words[a][i],&all_words[a][j])<0){
temporal=all_words[a][i];
all_words[a][i]=all_words[a][j];
all_words[a][j]=temporal; }}}}

for(int i=0;i<ex3;i++){
for(int j=0;j<ex3;j++){
if(strcmp(&waifu_name[i],&waifu_name[j])<0){
temporal=waifu_name[i];
waifu_name[i]=waifu_name[j];
waifu_name[j]=temporal; }}}

for(int i=0;i<ex1;i++){
if(strcmp(waifu_name,all_words[i])==0){
coincidencias++; }}
printf("%d",coincidencias);
return 0; }

lista_waifus = ["asuka","haruhi","Astolfo","akusa","sukaa","kAasu","kaasu","aksua","Tsunade","Mona china tetuda generica","Kobeni"]
nombre_waifu = list("asuka")
contador = 0
for x in lista_waifus:     
    if sorted(list(x.lower())) == sorted(nombre_waifu):
        contador +=1
print(contador)

ez, wai

*Ahem* OPerra aquí. Ya que el lenguaje es de elección libre y los creo suficientemente capaces de hacer un programa tan sencillo, supongo que opinaré usando un poco de análisis de algoritmos.

>>5452
En efecto, creo que te faltó optimizar pero como es C el tiempo de ejecución se salva un poco. Por ejemplo, esos tres for anidados son de complejidad O(n^3) si no mal recuerdo y quicksort es mejor que bubble sort, que para bien o mal le añade complejidad extra al último bucle. De haber optimizado esos puntos tu algoritmo sería el mejor del hilo.

Pero meh, yo usé js, que ya sé que básicamente es una forma de hacer trampa pues filter() no pasa de complejidad O(n). Aunque lamentablemente, sort() usa timsort, que es una implementación de mierda O(n log n) peor que quicksort y bubblesort así que yo igual pude haber optimizado lol.

>>5458
Muy limpio tu algoritmo, pero nuevamente, la implementación de sorted() de python es de la misma complejidad que la de javascript, o sea puede ser (mucho) mejor.

>>5459
No entiendo a donde quieres llegar con que puede ser mucho mejor

>>5459
Eres libre de autodenominarte cómo te de la gana pero por las dudas aclaro que realmente en esta página no hace falta auto humillarse de esa forma para interactuar con otras personas

>>5462
Ya lo expliqué. Creelo o no con este ejercicio se nota la experiencia y noción que tienen de optimización, que puede ser de mayor valor en proyectos más grandes donde si haya un repositorio y una pipeline que distribuya el software a producción.
Como sea, puede que ustedes lo hagan por simple reto. Yo sólo seguiré leyendo el código de los que sigan participando.
>>5465
Totalmente off-topic

>>5467

lista_waifus = ["asuka", "haruhi", "Astolfo", "akusa", "sukaa", "kAasu", "kaasu", "aksua", "Tsunade", "Mona china tetuda generica", "Kobeni"]
nombre_waifu = set("asuka".lower())
contador = sum(1 for x in lista_waifus if set(x.lower()) == nombre_waifu)
print(contador)

Te refieres a hacerlo algo mas así wai? aqui no se usa sorted().
Btw este código lo hice con ChatGPT, solo quería saber como se podía optimizar aun mas el codigo

Mi humilde aporte:

 assembly
.globl main

.section .data

main_string:
mstr_len:.quad mstr_end - mstr -1
mstr:.string "asuka"
mstr_end:

string_buffer:
str1_len:.quad str1_end - str1 -1
str1:.string "haruhi"
str1_end:

str2_len: .quad str2_end - str2 -1
str2:.string "azuka"
str2_end:

str3_len: .quad str3_end - str3 -1
str3:.string "aakus"
str3_end:

str4_len: .quad str4_end - str4 -1
str4:.string "asuki"
str4_end:

str5_len: .quad str5_end - str5 -1
str5:.string "asuka"
str5_end:

str0_len:.quad 0
str0:.ascii "\0"

str_fmt:
.string "%d anagramas\n"

.section .text
.equ STR_BUFF_PTR,-0x08
.equ NUM_ANAGRAMAS,-0x10
#.equ CURRENT_STR_PTR, -0x18
.equ NUM, -0x08
main:
enter $0x20, $0

movq $str3, %r10
movq $str3_len, %r11
movq $str0, %r12
movq $str0_len, %r13

# Ordenamos la cadena principal
movq $mstr, %rdi
movq mstr_len, %rsi
call sort_str

movq $string_buffer, STR_BUFF_PTR(%rbp)
movq $0, NUM_ANAGRAMAS(%rbp)

# Ordenamos y comparamos el resto de cadenas
main__loop:
movq STR_BUFF_PTR(%rbp), %rdx

leaq 8(%rdx), %rdi
movq (%rdx), %rsi

cmpq $0, (%rdi)
je main__print
cmpq $0, %rsi
je main__print

call sort_str

movq STR_BUFF_PTR(%rbp), %r8
leaq 8(%r8), %rdi
movq $mstr, %rsi
movq (%r8), %rdx
movq mstr_len, %rcx
call str_eq

cmpq $0, %rax
je main__loop_end

incq NUM_ANAGRAMAS(%rbp)

main__loop_end:
movq STR_BUFF_PTR(%rbp), %rdx
movq (%rdx), %rax
addq %rax, STR_BUFF_PTR(%rbp)
addq $(0x1 +0x08), STR_BUFF_PTR(%rbp)
movq STR_BUFF_PTR(%rbp), %rax
jmp main__loop

main__print:
movq $0, %rax
movq $str_fmt, %rdi
movq NUM_ANAGRAMAS(%rbp), %rsi
call printf

main__return:
movq $0, %rax
leave
ret




# %rdi - str ptr
# %rsi - str len without null
sort_str:
enter $0, $0

movq $0, %r8
sort_str__main_loop:
cmpq %rsi, %r8
jae sort_str__return

movq $0, %r9
sort_str__order_subarray:
cmpq %r8, %r9
jae sort_str__main_loop_end

movb (%rdi, %r8), %al
movb (%rdi, %r9), %bl
cmpb %al, %bl
jbe sort_str__order_subarray_end

sort_str__swap_values:
movb %bl, (%rdi, %r8)
movb %al, (%rdi, %r9)

sort_str__order_subarray_end:
incq %r9
jmp sort_str__order_subarray

sort_str__main_loop_end:
incq %r8
jmp sort_str__main_loop

sort_str__return:
leave
ret


# %rdi -> ptr to str1
# %rsi -> ptr to str2
# %rdx -> str1 len
# %rcx -> str2 len
str_eq:
enter $0, $0

cmpq %rdx, %rcx
jne str_eq__not_equal

str_eq__pre_loop:
movq $1, %rax
movq $0, %rcx
str_eq__loop:
cmpq %rdx, %rcx
jae str_eq__return

movb (%rdi, %rcx), %bl
cmpb (%rsi, %rcx), %bl
je str_eq__loop_end

str_eq__not_equal:
movq $0, %rax
jmp str_eq__return

str_eq__loop_end:
incq %rcx
jmp str_eq__loop


str_eq__return:
leave
ret

>>5467
Probablemente 5462-san entendió que su implementación podía ser modificada para ser mejor, mientras que tú intentaste decir que al usar el algoritmo de ordenamiento por defecto de python3 su programa reaccionaría mejor que si usara uno O(n^2).

Es importante saber leer y escribir.